home *** CD-ROM | disk | FTP | other *** search
/ Aminet 1 (Walnut Creek) / Aminet - June 1993 [Walnut Creek].iso / usenet / sources / volume90 / comm / dnet / dnet_213 / part05 < prev    next >
Text File  |  1990-03-27  |  58KB  |  2,656 lines
  1. Path: xanth!cs.odu.edu!Amiga-Request
  2. From: Amiga-Request@cs.odu.edu (Amiga Sources/Binaries Moderator)
  3. Newsgroups: comp.sources.amiga
  4. Subject: v90i122: DNet 2.13 - multiple windows/file transfers over a serial line, Part05/08
  5. Message-ID: <11942@xanth.cs.odu.edu>
  6. Date: 27 Mar 90 01:21:43 GMT
  7. Sender: tadguy@cs.odu.edu
  8. Reply-To: dales%teksce.sce.tek.com@RELAY.CS.NET
  9. Lines: 2642
  10. Approved: tadguy@cs.odu.edu (Tad Guy)
  11. X-Mail-Submissions-To: Amiga@cs.odu.edu
  12. X-Post-Discussions-To: comp.sys.amiga
  13.  
  14. Submitted-by: dales%teksce.sce.tek.com@RELAY.CS.NET
  15. Posting-number: Volume 90, Issue 122
  16. Archive-name: comm/dnet/dnet-2.13/part05
  17.  
  18. #!/bin/sh
  19. # This is a shell archive.  Remove anything before this line, then unpack
  20. # it by saving it into a file and typing "sh file".  To overwrite existing
  21. # files, type "sh file -c".  You can also feed this as standard input via
  22. # unshar, or by typing "sh <file", e.g..  If this archive is complete, you
  23. # will see the following message at the end:
  24. #        "End of archive 5 (of 8)."
  25. # Contents:  amiga/client/cliterm.c amiga/client/fterm.c
  26. #   amiga/client/getfiles.c amiga/dnet/sernet.c amiga/server/sgcopy.c
  27. #   unix/dnet/subs.c
  28. # Wrapped by tadguy@xanth on Mon Mar 26 20:15:18 1990
  29. PATH=/bin:/usr/bin:/usr/ucb ; export PATH
  30. if test -f 'amiga/client/cliterm.c' -a "${1}" != "-c" ; then 
  31.   echo shar: Will not clobber existing file \"'amiga/client/cliterm.c'\"
  32. else
  33. echo shar: Extracting \"'amiga/client/cliterm.c'\" \(7824 characters\)
  34. sed "s/^X//" >'amiga/client/cliterm.c' <<'END_OF_FILE'
  35. X
  36. X/*
  37. X *  CLITERM.C
  38. X *
  39. X *  DNET (c)Copyright 1988-1989, Matthew Dillon, All Rights Reserved.
  40. X *
  41. X *  FTERM [-Nnet] [port]
  42. X */
  43. X
  44. X#include "defs.h"
  45. X
  46. Xtypedef struct IORequest RIO;
  47. X
  48. X
  49. X#ifndef DEVICES_CONUNIT_H
  50. Xtypedef struct ConUnit        CONUNIT;
  51. Xtypedef struct IOStdReq     IOCON;
  52. X#endif
  53. X
  54. Xshort IgnoreNS = 0;
  55. X
  56. XTA Ta = { (ubyte *)"topaz", 8 };
  57. X
  58. XITEXT IText[] = {
  59. X    { 0, 1, JAM2, 0, 0, &Ta, (ubyte *)"Flush"          }
  60. X};
  61. X
  62. XITEM Item[] = {
  63. X    { NULL    , 0, 0, 100, 10, ITEMTEXT|COMMSEQ|ITEMENABLED|HIGHCOMP, 0, (APTR)&IText[0], NULL, 'o' }
  64. X};
  65. X
  66. XMENU Menu[] = {
  67. X    { NULL    , 0, 0, 100, 20, MENUENABLED, "Control", &Item[0] }
  68. X};
  69. X
  70. Xchar Title[80];
  71. X
  72. XNW Nw = {
  73. X    0, 12, 640, 60, -1, -1,
  74. X    NEWSIZE|CLOSEWINDOW|MENUPICK,
  75. X    WINDOWSIZING|WINDOWDRAG|WINDOWDEPTH|WINDOWCLOSE|NOCAREREFRESH|ACTIVATE,
  76. X    NULL, NULL, (ubyte *)Title, NULL, NULL,
  77. X    32, 32, -1, -1, WBENCHSCREEN
  78. X};
  79. X
  80. XWIN *Win;
  81. X
  82. Xextern int Enable_Abort;
  83. Xchar Buf[512];
  84. Xchar Term[64] = { "FTERM (UNNAMED SHELL)" };
  85. Xchar Cc;
  86. X
  87. Xstruct IntuitionBase *IntuitionBase;
  88. Xstruct GfxBase *GfxBase;
  89. XIOCON *iocr, *iocw;
  90. X
  91. Xvoid OpenConsole ARGS((WIN *, IOCON **, IOCON **));
  92. Xvoid HandleIoctl ARGS((short, short, char, WIN *, IOCON *));
  93. Xvoid CloseConsole ARGS((IOCON *, IOCON *));
  94. Xvoid setsize ARGS((IOCON *, void *, WIN *));
  95. Xvoid localecho ARGS((int));
  96. X
  97. Xvoid main ARGS((int, char **));
  98. X
  99. Xint
  100. Xbrk()
  101. X{
  102. X    return(0);
  103. X}
  104. X
  105. Xvoid
  106. Xmain(ac,av)
  107. Xchar *av[];
  108. X{
  109. X    void *chan;
  110. X    long imask, conmask, dmask, mask;
  111. X    char notdone = 1;
  112. X    char portspec = 0;
  113. X    char *host = NULL;
  114. X    uword port = PORT_AMIGASHELL;
  115. X    int i;
  116. X    int bp = 0;
  117. X    char inputbuf[256];
  118. X
  119. X    onbreak(brk);
  120. X    sprintf(Title, "CLITerm V%s%s opening, wait..", VERSION, CLITERM_VERSION);
  121. X    {
  122. X    short i;
  123. X    for (i = 1; i < ac; ++i) {
  124. X        if (strncmp(av[i], "-N", 2) == 0) {
  125. X        host = av[i] + 2;
  126. X        continue;
  127. X        }
  128. X        portspec = 1;
  129. X        port = atoi(av[i]);
  130. X    }
  131. X    }
  132. X    if (portspec)
  133. X    printf("Using port %ld\n", port);
  134. X#ifndef LATTICE
  135. X    Enable_Abort = 0;
  136. X#endif
  137. X    IntuitionBase = (struct IntuitionBase *)OpenLibrary("intuition.library", 0);
  138. X    GfxBase = (struct GfxBase *)OpenLibrary("graphics.library", 0);
  139. X    Win = OpenWindow(&Nw);
  140. X    if (Win == NULL)
  141. X    goto e1;
  142. X    OpenConsole(Win, &iocr, &iocw);
  143. X    if (iocr == NULL || iocw == NULL)
  144. X    goto e3;
  145. X
  146. X    /*
  147. X     *    We delay here to allow DNET to go through its RESTART sequence
  148. X     *    (when DNET automatically runs FTERM, it does so to quickly).
  149. X     *    Such a hack!
  150. X     */
  151. X
  152. X    Delay(50 * 4);
  153. X    chan = DOpen(host, port, 20, 15);
  154. X
  155. X    if (!chan) {
  156. X    puts("Unable to connect");
  157. X    goto e3;
  158. X    }
  159. X    DQueue(chan, 32);
  160. X    SetMenuStrip(Win, Menu);
  161. X    SetWindowTitles(Win, Term, (char *)-1);
  162. X    imask   = 1 << Win->UserPort->mp_SigBit;
  163. X    dmask   = 1 << ((PORT *)chan)->mp_SigBit;
  164. X    conmask = 1 << iocr->io_Message.mn_ReplyPort->mp_SigBit;
  165. X    iocr->io_Data = (APTR)&Cc;
  166. X    iocr->io_Length = 1;
  167. X    SendIO((RIO *)iocr);
  168. X
  169. X    setsize(iocw, chan, Win);
  170. X
  171. X    while (notdone) {
  172. X    mask = Wait(imask|dmask|conmask);
  173. X    if (mask & imask) {
  174. X        IMESS *im;
  175. X        while (im = (IMESS *)GetMsg(Win->UserPort)) {
  176. X        switch(im->Class) {
  177. X        case NEWSIZE:
  178. X            if (IgnoreNS) {
  179. X            --IgnoreNS;
  180. X            setsize(iocw, NULL, Win);
  181. X            } else {
  182. X            setsize(iocw, chan, Win);
  183. X            }
  184. X            break;
  185. X        case CLOSEWINDOW:
  186. X            notdone = 0;
  187. X            break;
  188. X        case MENUPICK:
  189. X            switch((uword)((MENUNUM(im->Code)<<8)|ITEMNUM(im->Code))) {
  190. X            case 0x0000:    /*    menu 0 item 0    */
  191. X            DIoctl(chan, CIO_FLUSH, 0, 0);
  192. X            break;
  193. X            case 0x0001:    /*    menu 0 item 1    */
  194. X            case 0x0002:    /*    menu 0 item 2    */
  195. X            case 0x0100:    /*    menu 1 item 0    */
  196. X            break;
  197. X            }
  198. X            break;
  199. X        default:
  200. X            break;
  201. X        }
  202. X        ReplyMsg((MSG *)im);
  203. X        }
  204. X    }
  205. X    if (mask & dmask) {
  206. X        char buf[256];
  207. X        int n;
  208. X        if ((n = DNRead(chan, buf, 256)) > 0) {
  209. X        for (i = 0; i < n; i++) {
  210. X            if (buf[i] == '\n') {
  211. X            movmem(&buf[i], &buf[i + 1], n - i);
  212. X            buf[i] = '\r';
  213. X            i++;
  214. X            n++;
  215. X            }
  216. X        }
  217. X        iocw->io_Data = (APTR)buf;
  218. X        iocw->io_Length = n;
  219. X        DoIO((RIO *)iocw);
  220. X        }
  221. X        if (n == -2) {
  222. X        short val;
  223. X        short cmd;
  224. X        char aux;
  225. X
  226. X        cmd = DGetIoctl(chan, &val, &aux);
  227. X        HandleIoctl(cmd, val, aux, Win, iocw);
  228. X        /*
  229. X        if (cmd == CIO_MODE) {
  230. X            if (val)
  231. X            SetWindowTitles(Win, "(Cooked)", (char *)-1);
  232. X            else
  233. X            SetWindowTitles(Win, "(Raw)", (char *)-1);
  234. X        }
  235. X        */
  236. X        } else if (n < 0)
  237. X        notdone = 0;
  238. X    }
  239. X    if (mask & conmask) {
  240. X        if (CheckIO((RIO *)iocr)) {
  241. X        WaitIO((RIO *)iocr);
  242. X
  243. X        if (Cc == '\r')
  244. X            Cc = '\n';
  245. X        inputbuf[bp++] = Cc;
  246. X
  247. X        if (Cc == 0x08) {
  248. X            if (bp <= 1) {
  249. X            bp = 0;
  250. X            } else {
  251. X            localecho(0x08);
  252. X            localecho(0x20);
  253. X            localecho(0x08);
  254. X            bp -= 2;
  255. X            }
  256. X        } else if (Cc == 0x18) {
  257. X            while (--bp > 0) {
  258. X            localecho(0x08);
  259. X            localecho(0x20);
  260. X            localecho(0x08);
  261. X            }
  262. X        } else if (Cc == '\n') {
  263. X            localecho('\n');
  264. X            localecho('\r');
  265. X            DWrite(chan, inputbuf, bp);
  266. X            bp = 0;
  267. X        } else {
  268. X            localecho(Cc);
  269. X        }
  270. X
  271. X        iocr->io_Data = (APTR)&Cc;
  272. X        iocr->io_Length = 1;
  273. X        SendIO((RIO *)iocr);
  274. X/*
  275. X        if (Cc == '\r') {
  276. X            Cc = '\n';
  277. X            DWrite(chan, &Cc, 1);
  278. X            iocr->io_Data = (APTR)&Cc;
  279. X            iocr->io_Length = 1;
  280. X            SendIO(iocr);
  281. X        }
  282. X*/
  283. X        }
  284. X    }
  285. X    }
  286. X    AbortIO((RIO *)iocr);
  287. X    WaitIO((RIO *)iocr);
  288. X    SetWindowTitles(Win, "Closing...", (char *)-1);
  289. X    DClose(chan);
  290. Xe3: CloseConsole(iocr,iocw);
  291. X    CloseWindow(Win);
  292. Xe1: CloseLibrary((LIB *)IntuitionBase);
  293. X    CloseLibrary((LIB *)GfxBase);
  294. X}
  295. X
  296. Xvoid
  297. Xlocalecho(c)
  298. Xint c;
  299. X{
  300. X    char cc;
  301. X
  302. X    cc = c;
  303. X    iocw->io_Data = (APTR)&cc;
  304. X    iocw->io_Length = 1;
  305. X    DoIO((RIO *)iocw);
  306. X}
  307. X
  308. Xvoid
  309. XOpenConsole(win, piocr, piocw)
  310. XIOCON **piocr, **piocw;
  311. XWIN *win;
  312. X{
  313. X    PORT *port;
  314. X    static IOCON iocr, iocw;
  315. X    int error;
  316. X
  317. X    port = CreatePort(NULL, 0);
  318. X    iocr.io_Command = CMD_READ;
  319. X    iocr.io_Data = (APTR)win;
  320. X    iocr.io_Message.mn_Node.ln_Type = NT_MESSAGE;
  321. X    iocr.io_Message.mn_ReplyPort = port;
  322. X    error = OpenDevice("console.device", 0, (RIO *)&iocr, 0);
  323. X    if (!error) {
  324. X    iocw = iocr;
  325. X    iocw.io_Command = CMD_WRITE;
  326. X    *piocr = &iocr;
  327. X    *piocw = &iocw;
  328. X    } else {
  329. X    *piocr = *piocw = NULL;
  330. X    }
  331. X}
  332. X
  333. Xvoid
  334. XCloseConsole(iocr, iocw)
  335. XIOCON *iocr;
  336. XIOCON *iocw;
  337. X{
  338. X    IOCON *tmp = (iocr) ? iocr : iocw;
  339. X    if (tmp) {
  340. X    CloseDevice((RIO *)tmp);
  341. X    DeletePort(tmp->io_Message.mn_ReplyPort);
  342. X    }
  343. X}
  344. X
  345. Xvoid
  346. Xsetsize(iocw, chan, win)
  347. XIOCON *iocw;
  348. Xvoid *chan;
  349. XWIN *win;
  350. X{
  351. X    struct ConUnit *cu = (struct ConUnit *)iocw->io_Unit;
  352. X    static char IStr[] = { "\033c\23320l\233t\233u" };
  353. X
  354. X    /*
  355. X    if (Cooked & 4)
  356. X    IStr[5] = 'h';
  357. X    else
  358. X    IStr[5] = 'l';
  359. X    */
  360. X    iocw->io_Data = (APTR)IStr;
  361. X    iocw->io_Length = sizeof(IStr) - 1;
  362. X    DoIO((RIO *)iocw);
  363. X    if (chan) {
  364. X    DIoctl(chan, CIO_SETROWS, (uword)(cu->cu_YMax+1), 0);
  365. X    DIoctl(chan, CIO_SETCOLS, (uword)(cu->cu_XMax+1), 0);
  366. X    }
  367. X    sprintf(Term, "FTERM   %ld x %ld", cu->cu_YMax+1, cu->cu_XMax+1);
  368. X    SetWindowTitles(win, Term, (char *)-1);
  369. X}
  370. X
  371. Xvoid
  372. XHandleIoctl(cmd, val, aux, win, iocw)
  373. Xshort cmd, val;
  374. Xchar aux;
  375. XWIN *win;
  376. XIOCON *iocw;
  377. X{
  378. X    static short saverows;
  379. X    short height, width;
  380. X    short dx, dy;
  381. X
  382. X    switch(cmd) {
  383. X    case CIO_MODE:
  384. X    /*
  385. X    Cooked = val;
  386. X    */
  387. X    break;
  388. X    case CIO_SETROWS:
  389. X    saverows = val;
  390. X    break;
  391. X    case CIO_SETCOLS:
  392. X    width = val * win->RPort->TxWidth + win->BorderLeft + win->BorderRight;
  393. X    height= saverows * win->RPort->TxHeight + win->BorderTop + win->BorderBottom;
  394. X
  395. X    dx = win->WScreen->Width - (win->LeftEdge + width);
  396. X    if (dx > 0)
  397. X        dx = 0;
  398. X    if (-dx > win->LeftEdge) {
  399. X        dx = -win->LeftEdge;
  400. X        width = win->WScreen->Width;
  401. X    }
  402. X
  403. X    dy = win->WScreen->Height - (win->TopEdge + height);
  404. X    if (dy > 0)
  405. X        dy = 0;
  406. X    if (-dy > win->TopEdge) {
  407. X        dy = -win->TopEdge;
  408. X        height = win->WScreen->Height;
  409. X    }
  410. X
  411. X    if (dx || dy) {
  412. X        MoveWindow(win, dx, dy);
  413. X    }
  414. X    if (win->Width != width || win->Height != height) {
  415. X        SizeWindow(win, width - win->Width, height - win->Height);
  416. X        ++IgnoreNS;
  417. X    }
  418. X    break;
  419. X    }
  420. X}
  421. X
  422. END_OF_FILE
  423. if test 7824 -ne `wc -c <'amiga/client/cliterm.c'`; then
  424.     echo shar: \"'amiga/client/cliterm.c'\" unpacked with wrong size!
  425. fi
  426. # end of 'amiga/client/cliterm.c'
  427. fi
  428. if test -f 'amiga/client/fterm.c' -a "${1}" != "-c" ; then 
  429.   echo shar: Will not clobber existing file \"'amiga/client/fterm.c'\"
  430. else
  431. echo shar: Extracting \"'amiga/client/fterm.c'\" \(9688 characters\)
  432. sed "s/^X//" >'amiga/client/fterm.c' <<'END_OF_FILE'
  433. X
  434. X/*
  435. X *  FTERM.C
  436. X *
  437. X *  DNET (c)Copyright 1988, Matthew Dillon, All Rights Reserved.
  438. X *
  439. X *  FTERM [-Nnet] [port] [-wcapturefile] [-c#]
  440. X *
  441. X *  -c# = cooked mode.    i.e. -c7    bit 0   convert CR's to LF's keyboard->remote
  442. X *                    bit 1   echo chars locally (half duplex)
  443. X *                    bit 2   received LF->CRLF
  444. X */
  445. X
  446. X#include "defs.h"
  447. X#include <local/deemu.h>
  448. X
  449. Xshort Deemu[] = {
  450. X    DMSTRT, 0, 0,
  451. X    DMNW  , 0,10, 11, 11, -37, -28, 0xFFFF,
  452. X    DMTEXT, 0,30, 'FO','NT','\0t','op','az','.f','on','t.','8\0',0,0,0,0,0,0,
  453. X    DMEND , 0, 0
  454. X};
  455. X
  456. X#define DMNWOFF     4
  457. X#define DMFONTSTR   17
  458. X
  459. XTA Ta = { (ubyte *)"topaz.font", 8 };
  460. X
  461. XITEXT IText[] = {
  462. X    { 0, 1, JAM2, 0, 0, &Ta, (ubyte *)"Flush"          },
  463. X    { 0, 1, JAM2, 0, 0, &Ta, (ubyte *)"AppendCap"      },
  464. X    { 0, 1, JAM2, 0, 0, &Ta, (ubyte *)"NewCap"         },
  465. X    { 0, 1, JAM2, 0, 0, &Ta, (ubyte *)"CloseCap"       },
  466. X    { 0, 1, JAM2, 0, 0, &Ta, (ubyte *)"Paste"          }
  467. X};
  468. X
  469. XITEM Item[] = {
  470. X    { &Item[1], 0, 0, 100, 10, ITEMTEXT|COMMSEQ|ITEMENABLED|HIGHCOMP, 0, (APTR)&IText[0], NULL, 'o' },
  471. X    { &Item[2], 0,10, 100, 10, ITEMTEXT|COMMSEQ|ITEMENABLED|HIGHCOMP, 0, (APTR)&IText[1], NULL, 'a' },
  472. X    { &Item[3], 0,20, 100, 10, ITEMTEXT|COMMSEQ|ITEMENABLED|HIGHCOMP, 0, (APTR)&IText[2], NULL, 'n' },
  473. X    { &Item[4], 0,30, 100, 10, ITEMTEXT|COMMSEQ|ITEMENABLED|HIGHCOMP, 0, (APTR)&IText[3], NULL, 'c' },
  474. X    { NULL    , 0,40, 100, 10, ITEMTEXT|COMMSEQ|ITEMENABLED|HIGHCOMP, 0, (APTR)&IText[4], NULL, 'p' }
  475. X};
  476. X
  477. XMENU Menu[] = {
  478. X    { NULL    , 0, 0, 100, 10+40, MENUENABLED, "Control", &Item[0] }
  479. X};
  480. X
  481. Xubyte Title[80];
  482. X
  483. XNW Nw = {
  484. X    0, 0, 640, 200, -1, -1,
  485. X    NEWSIZE|CLOSEWINDOW|MENUPICK,
  486. X    WINDOWSIZING|WINDOWDRAG|WINDOWDEPTH|WINDOWCLOSE|NOCAREREFRESH|ACTIVATE,
  487. X    NULL, NULL, Title, NULL, NULL,
  488. X    32, 32, -1, -1, WBENCHSCREEN
  489. X};
  490. X
  491. XWIN *Win;
  492. X
  493. Xextern int Enable_Abort;
  494. Xchar Buf[512];
  495. Xchar Term[64];
  496. Xchar Cc;
  497. Xchar Cooked;    /*  bit 0 = cooked,  bit 1 = local echo */
  498. Xchar IgnoreNS;
  499. X
  500. X
  501. X
  502. Xstruct IntuitionBase *IntuitionBase;
  503. Xstruct GfxBase *GfxBase;
  504. X
  505. Xvoid OpenConsole ARGS((WIN *, IOCON **, IOCON **));
  506. Xvoid HandleIoctl ARGS((short, short, char, WIN *, IOCON *));
  507. Xvoid CloseConsole ARGS((IOCON *, IOCON *));
  508. Xvoid setsize ARGS((IOCON *, void *, WIN *));
  509. X
  510. Xvoid main ARGS((int, char **));
  511. X
  512. Xint
  513. Xbrk()
  514. X{
  515. X    return(0);
  516. X}
  517. X
  518. Xvoid
  519. Xmain(ac, av)
  520. Xchar *av[];
  521. X{
  522. X    void *chan;
  523. X    long imask, conmask, dmask, mask;
  524. X    IOCON *iocr, *iocw;
  525. X    char notdone = 1;
  526. X    char portspec = 0;
  527. X    char *host = NULL;
  528. X    char *capfile = NULL;
  529. X    FILE *capfi = NULL;
  530. X    uword port = PORT_IALPHATERM;
  531. X    FONT *font = NULL;
  532. X
  533. X    onbreak(brk);
  534. X    sprintf(Title, "FTerm V%s%s", VERSION, FTERM_VERSION);
  535. X    strcpy(Term, Title);
  536. X    strcat(Title, " opening, wait ...");
  537. X
  538. X    {
  539. X    char *str = av[0];
  540. X    for (str = str + strlen(str); str >= av[0]; --str) {
  541. X        if (*str == '/' || *str == ':')
  542. X        break;
  543. X    }
  544. X    ++str;
  545. X    if ((*str | 0x20) == 'b')   /*  bbsterm instead of fterm    */
  546. X        port = PORT_BBS;
  547. X    }
  548. X
  549. X    {
  550. X    short i;
  551. X    for (i = 1; i < ac; ++i) {
  552. X        char *ptr = av[i];
  553. X        if (*ptr == '-') {
  554. X        while (*++ptr) {
  555. X            switch(*ptr) {
  556. X            case 'N':
  557. X            host = ptr + 1;
  558. X            ptr = "\0";
  559. X            break;
  560. X            case 'w':
  561. X            capfile = ptr + 1;
  562. X            ptr = "\0";
  563. X            break;
  564. X            case 'c':
  565. X            Cooked = atoi(ptr + 1);
  566. X            ptr = "\0";
  567. X            break;
  568. X            default:
  569. X            printf("Unknown option: '%c'\n", *ptr);
  570. X            break;
  571. X            }
  572. X        }
  573. X        } else {
  574. X        portspec = 1;
  575. X        port = atoi(ptr);
  576. X        }
  577. X    }
  578. X    }
  579. X    if (capfile)
  580. X    capfi = fopen(capfile, "a");
  581. X    if (portspec)
  582. X    printf("Using port %ld\n", port);
  583. X#ifndef LATTICE
  584. X    Enable_Abort = 0;
  585. X#endif
  586. X    IntuitionBase = (struct IntuitionBase *)OpenLibrary("intuition.library", 0);
  587. X    GfxBase = (struct GfxBase *)OpenLibrary("graphics.library", 0);
  588. X
  589. X    InitDeemuNW(Deemu+DMNWOFF, &Nw);
  590. X    {
  591. X    char *p1, *p2;
  592. X    p1 = (char *)(Deemu+DMFONTSTR) + strlen((char *)(Deemu+DMFONTSTR)) + 1;
  593. X    for (p2 = p1 + strlen(p1); p2 != p1 && *p2 != '.'; --p2);
  594. X    if (*p2 == '.') {
  595. X        *p2 = 0;
  596. X        font = (FONT *)GetFont(p1, (short)atoi(p2+1));
  597. X    }
  598. X    }
  599. X
  600. X    Win = OpenWindow(&Nw);
  601. X    if (Win == NULL)
  602. X    goto e1;
  603. X    if (font) {
  604. X    SetFont(Win->RPort, font);
  605. X    SetRast(Win->RPort, 0);
  606. X    RefreshWindowFrame(Win);
  607. X    }
  608. X    OpenConsole(Win, &iocr, &iocw);
  609. X    if (iocr == NULL || iocw == NULL)
  610. X    goto e3;
  611. X
  612. X    /*
  613. X     *    We delay here to allow DNET to go through its RESTART sequence
  614. X     *    (when DNET automatically runs FTERM, it does so to quickly).
  615. X     *    Such a hack!
  616. X     */
  617. X
  618. X    Delay(50 * 4);
  619. X    chan = DOpen(host, port, 20, 15);
  620. X
  621. X    if (!chan) {
  622. X    puts("Unable to connect");
  623. X    goto e3;
  624. X    }
  625. X    DQueue(chan, 32);
  626. X    SetMenuStrip(Win, Menu);
  627. X    SetWindowTitles(Win, Term, (char *)-1);
  628. X    imask   = 1 << Win->UserPort->mp_SigBit;
  629. X    dmask   = 1 << ((PORT *)chan)->mp_SigBit;
  630. X    conmask = 1 << iocr->io_Message.mn_ReplyPort->mp_SigBit;
  631. X
  632. X    iocr->io_Data = (APTR)&Cc;
  633. X    iocr->io_Length = 1;
  634. X    SendIO(iocr);
  635. X
  636. X    setsize(iocw, chan, Win);
  637. X    while (notdone) {
  638. X    mask = Wait(imask|dmask|conmask);
  639. X    if (mask & imask) {
  640. X        IMESS *im;
  641. X        while (im = (IMESS *)GetMsg(Win->UserPort)) {
  642. X        switch(im->Class) {
  643. X        case NEWSIZE:
  644. X            if (IgnoreNS) {
  645. X            --IgnoreNS;
  646. X            setsize(iocw, NULL, Win);
  647. X            } else {
  648. X            setsize(iocw, chan, Win);
  649. X            }
  650. X            break;
  651. X        case CLOSEWINDOW:
  652. X            notdone = 0;
  653. X            break;
  654. X        case MENUPICK:
  655. X            switch((uword)((MENUNUM(im->Code)<<8)|ITEMNUM(im->Code))) {
  656. X            case 0x0000:    /*    menu 0 item 0    */
  657. X            DIoctl(chan, CIO_FLUSH, 0, 0);
  658. X            break;
  659. X            case 0x0001:    /*    menu 0 item 1    */
  660. X            if (capfi)
  661. X                fclose(capfi);
  662. X            capfi = fopen("ram:capture", "a");
  663. X            break;
  664. X            case 0x0002:
  665. X            if (capfi)
  666. X                fclose(capfi);
  667. X            capfi = fopen("ram:capture", "w");
  668. X            break;
  669. X            case 0x0003:    /*    menu 0 item 2    */
  670. X            if (capfi)
  671. X                fclose(capfi);
  672. X            capfi = NULL;
  673. X            break;
  674. X            case 0x0004:    /*    menu 0 item 3    */
  675. X            {
  676. X                FILE *fi;
  677. X                long n;
  678. X                if (fi = fopen("ram:paste", "r")) {
  679. X                while ((n = fread(Buf, 1, sizeof(Buf), fi)) > 0) {
  680. X                    DWrite(chan, Buf, n);
  681. X                }
  682. X                fclose(fi);
  683. X                }
  684. X            }
  685. X            break;
  686. X            case 0x0100:    /*    menu 1 item 0    */
  687. X            break;
  688. X            }
  689. X        }
  690. X        ReplyMsg((MSG *)im);
  691. X        }
  692. X    }
  693. X    if (mask & dmask) {
  694. X        int n;
  695. X        if ((n = DNRead(chan, Buf, sizeof(Buf))) > 0) {
  696. X        iocw->io_Data = (APTR)Buf;
  697. X        iocw->io_Length = n;
  698. X        DoIO(iocw);
  699. X        if (capfi)
  700. X            fwrite(Buf, n, 1, capfi);
  701. X        } else if (n == -2) {
  702. X        short val;
  703. X        short cmd;
  704. X        char aux;
  705. X        cmd = DGetIoctl(chan, &val, &aux);
  706. X        HandleIoctl(cmd, val, aux, Win, iocw);
  707. X        if (cmd == CIO_MODE) {
  708. X            if (val)
  709. X            SetWindowTitles(Win, "(Cooked)", (char *)-1);
  710. X            else
  711. X            SetWindowTitles(Win, "(Raw)", (char *)-1);
  712. X        }
  713. X        } else if (n < 0) {
  714. X        notdone = 0;
  715. X        }
  716. X    }
  717. X    if (mask & conmask) {
  718. X        if (CheckIO(iocr)) {
  719. X        WaitIO(iocr);
  720. X        if (Cooked & 2) {       /*  Local Echo  */
  721. X            iocw->io_Data = (APTR)&Cc;
  722. X            iocw->io_Length = 1;
  723. X            DoIO(iocw);
  724. X        }
  725. X        if ((Cooked & 1) && Cc == 13) {
  726. X            Cc = 10;
  727. X            iocw->io_Data = (APTR)&Cc;
  728. X            iocw->io_Length = 1;
  729. X            DoIO(iocw);
  730. X        }
  731. X        DWrite(chan, &Cc, 1);
  732. X        iocr->io_Data = (APTR)&Cc;
  733. X        iocr->io_Length = 1;
  734. X        SendIO(iocr);
  735. X        }
  736. X    }
  737. X    }
  738. X    AbortIO(iocr);
  739. X    WaitIO(iocr);
  740. X    SetWindowTitles(Win, "Closing...", (char *)-1);
  741. X    DClose(chan);
  742. Xe3: CloseConsole(iocr,iocw);
  743. X    if (font) {
  744. X    SetFont(Win->RPort, Win->WScreen->RastPort.Font);
  745. X    CloseFont(font);
  746. X    }
  747. X    CloseWindow(Win);
  748. Xe1: CloseLibrary((LIB *)IntuitionBase);
  749. X    CloseLibrary((LIB *)GfxBase);
  750. X    if (capfi)
  751. X    fclose(capfi);
  752. X}
  753. X
  754. Xvoid
  755. XOpenConsole(win, piocr, piocw)
  756. XIOCON **piocr, **piocw;
  757. XWIN *win;
  758. X{
  759. X    PORT *port;
  760. X    static IOCON iocr, iocw;
  761. X    int error;
  762. X
  763. X    port = CreatePort(NULL, 0);
  764. X    iocr.io_Command = CMD_READ;
  765. X    iocr.io_Data = (APTR)win;
  766. X    iocr.io_Message.mn_Node.ln_Type = NT_MESSAGE;
  767. X    iocr.io_Message.mn_ReplyPort = port;
  768. X    error = OpenDevice("console.device", 0, &iocr, 0);
  769. X    if (!error) {
  770. X    iocw = iocr;
  771. X    iocw.io_Command = CMD_WRITE;
  772. X    *piocr = &iocr;
  773. X    *piocw = &iocw;
  774. X    } else {
  775. X    *piocr = *piocw = NULL;
  776. X    }
  777. X}
  778. X
  779. Xvoid
  780. XCloseConsole(iocr, iocw)
  781. XIOCON *iocr;
  782. XIOCON *iocw;
  783. X{
  784. X    IOCON *tmp = (iocr) ? iocr : iocw;
  785. X    if (tmp) {
  786. X    CloseDevice(tmp);
  787. X    DeletePort(tmp->io_Message.mn_ReplyPort);
  788. X    }
  789. X}
  790. X
  791. Xvoid
  792. Xsetsize(iocw, chan, win)
  793. XIOCON *iocw;
  794. Xvoid *chan;
  795. XWIN *win;
  796. X{
  797. X    struct ConUnit *cu = (struct ConUnit *)iocw->io_Unit;
  798. X    static char IStr[] = { "\033c\23320l\233t\233u" };
  799. X
  800. X    if (Cooked & 4)
  801. X    IStr[5] = 'h';
  802. X    else
  803. X    IStr[5] = 'l';
  804. X    iocw->io_Data = (APTR)IStr;
  805. X    iocw->io_Length = sizeof(IStr) - 1;
  806. X    DoIO(iocw);
  807. X    if (chan) {
  808. X    DIoctl(chan, CIO_SETROWS, (uword)(cu->cu_YMax+1), 0);
  809. X    DIoctl(chan, CIO_SETCOLS, (uword)(cu->cu_XMax+1), 0);
  810. X    }
  811. X    sprintf(Term, "FTERM   %ld x %ld", cu->cu_YMax+1, cu->cu_XMax+1);
  812. X    SetWindowTitles(win, Term, (char *)-1);
  813. X}
  814. X
  815. Xvoid
  816. XHandleIoctl(cmd, val, aux, win, iocw)
  817. Xshort cmd, val;
  818. Xchar aux;
  819. XWIN *win;
  820. XIOCON *iocw;
  821. X{
  822. X    static short saverows;
  823. X    short height, width;
  824. X    short dx, dy;
  825. X
  826. X    switch(cmd) {
  827. X    case CIO_MODE:
  828. X    Cooked = val;
  829. X    break;
  830. X    case CIO_SETROWS:
  831. X    saverows = val;
  832. X    break;
  833. X    case CIO_SETCOLS:
  834. X    width = val * win->RPort->TxWidth + win->BorderLeft + win->BorderRight;
  835. X    height= saverows * win->RPort->TxHeight + win->BorderTop + win->BorderBottom;
  836. X
  837. X    dx = win->WScreen->Width - (win->LeftEdge + width);
  838. X    if (dx > 0)
  839. X        dx = 0;
  840. X    if (-dx > win->LeftEdge) {
  841. X        dx = -win->LeftEdge;
  842. X        width = win->WScreen->Width;
  843. X    }
  844. X
  845. X    dy = win->WScreen->Height - (win->TopEdge + height);
  846. X    if (dy > 0)
  847. X        dy = 0;
  848. X    if (-dy > win->TopEdge) {
  849. X        dy = -win->TopEdge;
  850. X        height = win->WScreen->Height;
  851. X    }
  852. X
  853. X    if (dx || dy) {
  854. X        MoveWindow(win, dx, dy);
  855. X    }
  856. X    if (win->Width != width || win->Height != height) {
  857. X        SizeWindow(win, width - win->Width, height - win->Height);
  858. X        ++IgnoreNS;
  859. X    }
  860. X    break;
  861. X    }
  862. X}
  863. X
  864. X
  865. END_OF_FILE
  866. if test 9688 -ne `wc -c <'amiga/client/fterm.c'`; then
  867.     echo shar: \"'amiga/client/fterm.c'\" unpacked with wrong size!
  868. fi
  869. # end of 'amiga/client/fterm.c'
  870. fi
  871. if test -f 'amiga/client/getfiles.c' -a "${1}" != "-c" ; then 
  872.   echo shar: Will not clobber existing file \"'amiga/client/getfiles.c'\"
  873. else
  874. echo shar: Extracting \"'amiga/client/getfiles.c'\" \(8775 characters\)
  875. sed "s/^X//" >'amiga/client/getfiles.c' <<'END_OF_FILE'
  876. X
  877. X/*
  878. X *  GETFILES.C        V1.30
  879. X *
  880. X *  DNET (c)Copyright 1988, Matthew Dillon, All Rights Reserved.
  881. X *
  882. X *
  883. X *  GETFILES [-Nnetid] [-dlocaldir] [-c] file/dir file/dir file/dir
  884. X *
  885. X *  -Nnetid    network identifier
  886. X *
  887. X *  -dlocaldir    local directory to place files
  888. X *
  889. X *  -c        Continue from where you left off before.  Files that already
  890. X *        exist on the local machine will not be re-transfered.  This
  891. X *        will also re-start in the middle of a file that was
  892. X *        partially transfered previously.
  893. X *
  894. X *        This command assumes the file(s) on both machines have not
  895. X *        been modified since the first attempt.    No other checking
  896. X *        is done at the moment.
  897. X */
  898. X
  899. X#include "defs.h"
  900. X
  901. Xvoid main ARGS((int, char **));
  902. X
  903. Xtypedef struct {
  904. X    char    Cmd;
  905. X    char    Str[128];
  906. X    long    Val;
  907. X} HDR;
  908. X
  909. X
  910. Xextern int Enable_Abort;
  911. X
  912. Xchar Buf[4096];
  913. X
  914. Xshort ContMode;
  915. Xchar  *NetId;
  916. Xlong  LocalDirLock;
  917. Xvoid *Chan;
  918. X
  919. Xvoid fail ARGS((int));
  920. Xint CheckNoPath ARGS((char *));
  921. Xint LostChannel ARGS((void));
  922. Xvoid UnknownCmd ARGS((HDR *));
  923. Xint GetFile ARGS((HDR *, int));
  924. Xint GetDir ARGS((HDR *, int));
  925. Xint WriteHeader ARGS((char, char *, long));
  926. Xint ReadHeader ARGS((HDR *));
  927. Xchar *NSpaces ARGS((int));
  928. Xint CheckBreak ARGS((void));
  929. Xvoid ResetBreak ARGS((void));
  930. X
  931. Xint brk()
  932. X{
  933. X    return(0);
  934. X}
  935. X
  936. X
  937. Xvoid
  938. Xmain(ac,av)
  939. Xint ac;
  940. Xchar *av[];
  941. X{
  942. X    HDR Hdr;
  943. X    short error;
  944. X
  945. X    onbreak(brk);
  946. X#ifndef LATTICE
  947. X    Enable_Abort = 0;
  948. X#endif
  949. X    printf("GetFiles V%s%s\n", VERSION, GETFILES_VERSION);
  950. X    ResetBreak();
  951. X    {
  952. X    char *ldir = "";
  953. X    FIB *fib = malloc(sizeof(FIB));
  954. X    ac = DoOption(ac, av, "N%sd%sc", &NetId, &ldir, &ContMode);
  955. X    if (ac <= 1) {
  956. X        puts("GETFILES [-Nnetid -dlocaldir -c] remotefile/dir ...");
  957. X        fail(22);
  958. X    }
  959. X    LocalDirLock = Lock(ldir, SHARED_LOCK);
  960. X    if (!LocalDirLock && ldir[0]) {     /*  couldn't find it, try to make it */
  961. X        if (LocalDirLock = (long)CreateDir(ldir)) {
  962. X        UnLock(LocalDirLock);
  963. X        LocalDirLock = Lock(ldir, SHARED_LOCK);
  964. X        }
  965. X    }
  966. X    if (!LocalDirLock || !Examine(LocalDirLock, fib) || fib->fib_DirEntryType < 0) {
  967. X        printf("Unable to CD or create local directory: \"%s\"\n", ldir);
  968. X        fail(21);
  969. X    }
  970. X    }
  971. X    Chan = DOpen(NetId, PORT_GFILECOPY, 126, -80);
  972. X    if (!Chan) {
  973. X    puts("Unable to connect");
  974. X    fail(20);
  975. X    }
  976. X    error = WriteHeader('H', "Hello, getfiles client V1.30", 0);
  977. X    if (error)
  978. X    fail(LostChannel());
  979. X    switch(ReadHeader(&Hdr)) {
  980. X    case -1:
  981. X    fail(LostChannel());
  982. X    case 'H':
  983. X    printf("%s\n", Hdr.Str);
  984. X    break;
  985. X    }
  986. X    {
  987. X    short i;
  988. X
  989. X    for (i = 1; i < ac; ++i) {
  990. X        short error;
  991. X
  992. X        error = WriteHeader('G', av[i], 0);
  993. X        if (error)
  994. X        fail(LostChannel());
  995. X        switch(ReadHeader(&Hdr)) {
  996. X        case -1:
  997. X        fail(LostChannel());
  998. X        case 'N':
  999. X        printf("Remote error on %s: %s\n", av[i], Hdr.Str);
  1000. X        break;
  1001. X        case 'F':
  1002. X        error = CheckNoPath(Hdr.Str);
  1003. X        if (!error) {
  1004. X            long olddir = (long)CurrentDir(LocalDirLock);
  1005. X            error = GetFile(&Hdr, 0);
  1006. X            CurrentDir(olddir);
  1007. X        }
  1008. X        break;
  1009. X        case 'D':
  1010. X        error = CheckNoPath(Hdr.Str);
  1011. X        if (!error) {
  1012. X            long olddir = (long)CurrentDir(LocalDirLock);
  1013. X            error = GetDir(&Hdr, 0);
  1014. X            CurrentDir(olddir);
  1015. X        }
  1016. X        break;
  1017. X        case 'S':
  1018. X        printf("Access Violation: %s\n", Hdr.Str);
  1019. X        break;
  1020. X        default:
  1021. X        UnknownCmd(&Hdr);
  1022. X        error = 1;
  1023. X        break;
  1024. X        }
  1025. X        if (error)
  1026. X        fail(error);
  1027. X    }
  1028. X    if (!error) {
  1029. X        error = WriteHeader('E', "bye", 0);
  1030. X        if (error)
  1031. X        fail(LostChannel());
  1032. X    }
  1033. X    }
  1034. X    fail(0);
  1035. X}
  1036. X
  1037. Xvoid
  1038. Xfail(code)
  1039. X{
  1040. X    if (Chan)
  1041. X    DClose(Chan);
  1042. X    if (LocalDirLock)
  1043. X    UnLock(LocalDirLock);
  1044. X    exit(code);
  1045. X}
  1046. X
  1047. Xint
  1048. XCheckNoPath(str)
  1049. Xchar *str;
  1050. X{
  1051. X    while (*str) {
  1052. X    if (*str == '/' || *str == ':') {
  1053. X        puts("SECURITY ALERT: Illegal path spec received");
  1054. X        return(40);
  1055. X    }
  1056. X    ++str;
  1057. X    }
  1058. X    return(0);
  1059. X}
  1060. X
  1061. Xint
  1062. XLostChannel()
  1063. X{
  1064. X    puts("DATA CHANNEL LOST");
  1065. X    return(10);
  1066. X}
  1067. X
  1068. Xvoid
  1069. XUnknownCmd(hdr)
  1070. XHDR *hdr;
  1071. X{
  1072. X    printf("UnRecognized command code: %02x\n", hdr->Cmd);
  1073. X}
  1074. X
  1075. X/*
  1076. X *  retrieve a file.  If ContMode set and file exists, try to append to
  1077. X *  it.
  1078. X */
  1079. X
  1080. Xint
  1081. XGetFile(hdr, stab)
  1082. XHDR *hdr;
  1083. Xint stab;
  1084. X{
  1085. X    long Fh = NULL;
  1086. X    long pos = 0;
  1087. X    short error = 0;
  1088. X
  1089. X    printf("%s%-20s ", NSpaces(stab), hdr->Str);
  1090. X    fflush(stdout);
  1091. X    if (ContMode) {
  1092. X    SetProtection(hdr->Str, 0);         /*  make sure it's r/w  */
  1093. X    if (Fh = Open(hdr->Str, 1005)) {    /*  already exists  */
  1094. X        long len;
  1095. X
  1096. X        Seek(Fh, 0L, 1);
  1097. X        len = Seek(Fh, 0L, 0);          /*  get length      */
  1098. X        if (len > hdr->Val) {
  1099. X        Close(Fh);
  1100. X        printf("Cont Error, local file is larger than remote!: %s\n", hdr->Str);
  1101. X        puts("(not downloaded)");
  1102. X        return(0);
  1103. X        }
  1104. X        if (len == hdr->Val) {
  1105. X        Close(Fh);
  1106. X        if (error = WriteHeader('S', NULL, 0))
  1107. X            return(LostChannel());
  1108. X        puts("HAVE IT, SKIP");
  1109. X        return(0);
  1110. X        }
  1111. X        printf("(HAVE %ld/%ld) ", len, hdr->Val);
  1112. X        hdr->Val -= len;        /*  that much less  */
  1113. X        pos = len;            /*  start at offset */
  1114. X    }
  1115. X    }
  1116. X    if (!Fh) {
  1117. X    Fh = Open(hdr->Str, 1006);
  1118. X    if (!Fh) {
  1119. X        error = WriteHeader('N', "open error", 0);
  1120. X        printf("Unable to open %s for output\n", hdr->Str);
  1121. X        if (error)
  1122. X        return(LostChannel());
  1123. X        return(1);
  1124. X    }
  1125. X    }
  1126. X    error = WriteHeader('Y', NULL, pos);    /*  yes, gimme gimme    */
  1127. X
  1128. X    /*
  1129. X     *    Retrieve the data
  1130. X     */
  1131. X
  1132. X    if (!error) {
  1133. X    long left = hdr->Val;
  1134. X    long cnt = pos;
  1135. X    long total = pos + left;
  1136. X
  1137. X    while (left) {
  1138. X        long n = (left > sizeof(Buf)) ? sizeof(Buf) : left;
  1139. X        printf("%6ld/%6ld\23313D", cnt, total);
  1140. X        fflush(stdout);
  1141. X        if (DRead(Chan, Buf, n) != n) {
  1142. X        error = 5;
  1143. X        break;
  1144. X        }
  1145. X        if (CheckBreak()) {
  1146. X        error = 1;
  1147. X        break;
  1148. X        }
  1149. X        if (Write(Fh, Buf, n) != n) {
  1150. X        puts("Local Write failed!");
  1151. X        error = 6;
  1152. X        break;
  1153. X        }
  1154. X        left -= n;
  1155. X        cnt += n;
  1156. X        if (CheckBreak()) {
  1157. X        error = 1;
  1158. X        break;
  1159. X        }
  1160. X    }
  1161. X    printf("%6ld/%6ld  %s", cnt, total, ((cnt == total) ? "OK" : "INCOMPLETE"));
  1162. X    }
  1163. X    Close(Fh);
  1164. X    puts("");
  1165. X    if (error) {
  1166. X    SetProtection(hdr->Str, 10);    /*  disallow reads! */
  1167. X    return(LostChannel());
  1168. X    }
  1169. X    return((int)error);
  1170. X}
  1171. X
  1172. X/*
  1173. X *  Retrieve a directory.  Create it if necessary.
  1174. X */
  1175. X
  1176. Xint
  1177. XGetDir(hdr, stab)
  1178. XHDR *hdr;
  1179. Xint stab;
  1180. X{
  1181. X    short error = 0;
  1182. X    long dirlock;
  1183. X    static HDR Hdr;        /*    note: static */
  1184. X
  1185. X    if (CheckBreak())
  1186. X    return(1);
  1187. X    printf("%s%-20s(DIR)\n", NSpaces(stab), hdr->Str);
  1188. X    dirlock = Lock(hdr->Str, SHARED_LOCK);  /*  try to lock directory */
  1189. X    if (!dirlock) {
  1190. X    if (dirlock = (long)CreateDir(hdr->Str)) {
  1191. X        UnLock(dirlock);
  1192. X        dirlock = Lock(hdr->Str, SHARED_LOCK);
  1193. X    }
  1194. X    }
  1195. X    if (!dirlock) {
  1196. X    error = WriteHeader('N', "couldn't create", 0);
  1197. X    printf("Unable to create local directory: %s\n", hdr->Str);
  1198. X    if (error)
  1199. X        return(LostChannel());
  1200. X    return(1);
  1201. X    }
  1202. X    error = WriteHeader('Y', NULL, 0);  /*  yes, gimme gimme    */
  1203. X    while (!error) {
  1204. X    switch(ReadHeader(&Hdr)) {
  1205. X    case -1:
  1206. X        error = 1;
  1207. X        break;
  1208. X    case 'E':                   /*  end of directory    */
  1209. X        UnLock(dirlock);
  1210. X        return(0);
  1211. X        break;
  1212. X    case 'F':
  1213. X        error = CheckNoPath(Hdr.Str);
  1214. X        if (!error) {
  1215. X        long olddir = (long)CurrentDir(dirlock);
  1216. X        error = GetFile(&Hdr, stab + 4);
  1217. X        CurrentDir(olddir);
  1218. X        }
  1219. X        break;
  1220. X    case 'D':
  1221. X        error = CheckNoPath(Hdr.Str);
  1222. X        if (!error) {
  1223. X        long olddir = (long)CurrentDir(dirlock);
  1224. X        error = GetDir(&Hdr, stab + 4);
  1225. X        CurrentDir(olddir);
  1226. X        }
  1227. X        break;
  1228. X    case 'S':
  1229. X        printf("Access Violation: %s\n", Hdr.Str);
  1230. X        break;
  1231. X    case 'N':
  1232. X        printf("REMOTE ERROR: %s\n", Hdr.Str);
  1233. X        error = 10;
  1234. X        break;
  1235. X    default:
  1236. X        UnknownCmd(&Hdr);
  1237. X        error = 1;
  1238. X        break;
  1239. X    }
  1240. X    }
  1241. X    UnLock(dirlock);
  1242. X    return(LostChannel());
  1243. X}
  1244. X
  1245. Xint
  1246. XWriteHeader(c, str, len)
  1247. Xchar c;
  1248. Xchar *str;
  1249. Xlong len;
  1250. X{
  1251. X    ubyte sl;
  1252. X
  1253. X    if (str == NULL)
  1254. X    str = "";
  1255. X    sl = strlen(str);
  1256. X
  1257. X    if (DWrite(Chan, &c, 1) < 0)
  1258. X    return(1);
  1259. X    if (DWrite(Chan, &sl,1) < 0)
  1260. X    return(1);
  1261. X    if (DWrite(Chan, str, sl) != sl)
  1262. X    return(1);
  1263. X    if (DWrite(Chan, &len, 4) != 4)
  1264. X    return(1);
  1265. X    return(0);
  1266. X}
  1267. X
  1268. Xint
  1269. XReadHeader(hdr)
  1270. XHDR *hdr;
  1271. X{
  1272. X    ubyte sl;
  1273. X    ubyte cmd;
  1274. X
  1275. X    hdr->Cmd = -1;
  1276. X    if (DRead(Chan, &cmd, 1) != 1)
  1277. X    return(-1);
  1278. X    if (DRead(Chan, &sl, 1) != 1)
  1279. X    return(-1);
  1280. X    if (sl >= sizeof(hdr->Str)) {
  1281. X    puts("Software error: received file name length too long");
  1282. X    return(-1);
  1283. X    }
  1284. X    if (DRead(Chan, hdr->Str, sl) != sl)
  1285. X    return(-1);
  1286. X    hdr->Str[sl] = 0;
  1287. X    if (DRead(Chan, &hdr->Val, 4) != 4)
  1288. X    return(-1);
  1289. X    hdr->Cmd = cmd;
  1290. X    return((int)hdr->Cmd);
  1291. X}
  1292. X
  1293. Xchar *
  1294. XNSpaces(n)
  1295. Xint n;
  1296. X{
  1297. X    static char Buf[128];
  1298. X    static short in = 0;
  1299. X    static short last;
  1300. X
  1301. X    if (in == 0) {
  1302. X    in = 1;
  1303. X    BSet(Buf, sizeof(Buf)-1, ' ');
  1304. X    }
  1305. X    Buf[last] = ' ';
  1306. X    if (n < 127)
  1307. X    Buf[n] = 0;
  1308. X    last = n;
  1309. X    return(Buf);
  1310. X}
  1311. X
  1312. Xint
  1313. XCheckBreak()
  1314. X{
  1315. X    if (SetSignal(0,0) & (SIGBREAKF_CTRL_C|SIGBREAKF_CTRL_D)) {
  1316. X    puts("^C");
  1317. X    return(1);
  1318. X    }
  1319. X    return(0);
  1320. X}
  1321. X
  1322. Xvoid
  1323. XResetBreak()
  1324. X{
  1325. X    SetSignal(0, SIGBREAKF_CTRL_C|SIGBREAKF_CTRL_D);
  1326. X}
  1327. X
  1328. END_OF_FILE
  1329. if test 8775 -ne `wc -c <'amiga/client/getfiles.c'`; then
  1330.     echo shar: \"'amiga/client/getfiles.c'\" unpacked with wrong size!
  1331. fi
  1332. # end of 'amiga/client/getfiles.c'
  1333. fi
  1334. if test -f 'amiga/dnet/sernet.c' -a "${1}" != "-c" ; then 
  1335.   echo shar: Will not clobber existing file \"'amiga/dnet/sernet.c'\"
  1336. else
  1337. echo shar: Extracting \"'amiga/dnet/sernet.c'\" \(8314 characters\)
  1338. sed "s/^X//" >'amiga/dnet/sernet.c' <<'END_OF_FILE'
  1339. X
  1340. X/*
  1341. X *  SERNET.C
  1342. X *
  1343. X *  DNET (c)Copyright 1988, Matthew Dillon, All Rights Reserved.
  1344. X *
  1345. X *  NetWork device interface.
  1346. X */
  1347. X
  1348. X#include "dnet.h"
  1349. X
  1350. XIOSER *NetAbortRead();
  1351. Xvoid NetWaitWrite();
  1352. Xvoid SaveState();
  1353. Xvoid RestoreState();
  1354. Xvoid NetSerialOff();
  1355. Xvoid NetSerialOn();
  1356. X
  1357. Xstatic IOSER Iosw;
  1358. Xstatic ubyte IoswIP;
  1359. Xstatic ubyte LastWasWrite;
  1360. X
  1361. Xstatic ubyte IosrIP;
  1362. Xstatic ubyte RBuf[MAXPACKET*2];     /*    Recv Buf.            */
  1363. X
  1364. Xstatic IOSER *CNet;            /*    control-req (synchro)       */
  1365. Xstatic IOSER *RNet;            /*    read-request            */
  1366. Xstatic ubyte SerialIsOpen;        /*    serial device is open         */
  1367. Xstatic ubyte RecvEnabled = 1;
  1368. Xstatic char *DevName;
  1369. Xstatic long UnitNum;
  1370. X
  1371. Xvoid
  1372. XNetOpen(iosink, devname, unitnum, pbaud)
  1373. XPORT *iosink;
  1374. Xchar *devname;
  1375. Xlong *pbaud;
  1376. X{
  1377. X    IOSER ios;
  1378. X    long baud = *pbaud;
  1379. X
  1380. X    DevName = devname;
  1381. X    UnitNum = unitnum;
  1382. X
  1383. X    printf("netopen %s %d\n", devname, unitnum);
  1384. X
  1385. X    BZero(&ios, sizeof(ios));
  1386. X    ios.io_CtlChar = 0x11130102;
  1387. X    ios.io_SerFlags = SERF_SHARED;
  1388. X    if (OpenDevice(devname, unitnum, (IOR *)&ios, 0))
  1389. X    dneterror(devname);
  1390. X    ios.IOSer.io_Message.mn_ReplyPort = iosink;
  1391. X    SerialIsOpen = 1;
  1392. X
  1393. X    RNet = (IOSER *)AllocMem(sizeof(IOSER), MEMF_PUBLIC);
  1394. X    CNet = (IOSER *)AllocMem(sizeof(IOSER), MEMF_PUBLIC);
  1395. X    *RNet = ios;
  1396. X    *CNet = ios;
  1397. X
  1398. X    {
  1399. X    IOSER *ioc = CNet;
  1400. X
  1401. X    ioc->IOSer.io_Command = SDCMD_QUERY;
  1402. X    DoIO((IOR *)ioc);
  1403. X
  1404. X    if (Getty == 0) {
  1405. X        ioc->IOSer.io_Command = SDCMD_SETPARAMS;
  1406. X
  1407. X        if (baud)
  1408. X        ioc->io_Baud = baud;
  1409. X
  1410. X        ioc->io_SerFlags |= SERF_SHARED;
  1411. X        ioc->io_CtlChar = 0x01020304;
  1412. X
  1413. X        if (Protocol >= 0) {
  1414. X        ioc->io_SerFlags |= SERF_XDISABLED|SERF_RAD_BOOGIE;
  1415. X
  1416. X        switch(Protocol) {
  1417. X        case 0:
  1418. X            break;
  1419. X        case 1:     /*    xon-xoff    */
  1420. X            Mode7 = 1;
  1421. X            ioc->io_SerFlags &= ~(SERF_XDISABLED | SERF_RAD_BOOGIE);
  1422. X            break;
  1423. X        case 2:
  1424. X        case 7:
  1425. X            ioc->io_SerFlags |= SERF_7WIRE;
  1426. X            break;
  1427. X        }
  1428. X        }
  1429. X
  1430. X        if (Parity >= 0) {
  1431. X        ioc->io_ReadLen = ioc->io_WriteLen = 7;
  1432. X        ioc->io_SerFlags &= ~(SERF_PARTY_ON|SERF_PARTY_ODD);
  1433. X        ioc->io_ExtFlags &= ~(SEXTF_MSPON|SEXTF_MARK);
  1434. X        ioc->io_SerFlags &= ~SERF_RAD_BOOGIE;
  1435. X        switch(Parity) {
  1436. X        case 0:
  1437. X            ioc->io_ReadLen = ioc->io_WriteLen = 8;
  1438. X            if (Protocol != 1)
  1439. X            ioc->io_SerFlags |= SERF_RAD_BOOGIE;
  1440. X            break;
  1441. X        case 1:
  1442. X            ioc->io_SerFlags |= SERF_PARTY_ON | SERF_PARTY_ODD;
  1443. X            break;
  1444. X        case 2:
  1445. X            ioc->io_SerFlags |= SERF_PARTY_ON;
  1446. X            break;
  1447. X        case 3:
  1448. X            ioc->io_SerFlags |= SERF_PARTY_ON;
  1449. X            ioc->io_ExtFlags |= SEXTF_MSPON | SEXTF_MARK;
  1450. X            break;
  1451. X        case 4:
  1452. X            ioc->io_SerFlags |= SERF_PARTY_ON;
  1453. X            ioc->io_ExtFlags |= SEXTF_MSPON;
  1454. X            break;
  1455. X        }
  1456. X        }
  1457. X        printf("parity is ");
  1458. X        if (ioc->io_SerFlags & SERF_PARTY_ON) {
  1459. X        if (ioc->io_ExtFlags & SEXTF_MSPON) {
  1460. X            if (ioc->io_ExtFlags & SEXTF_MARK)
  1461. X            puts("mark");
  1462. X            else
  1463. X            puts("space");
  1464. X        } else {
  1465. X            if (ioc->io_SerFlags & SERF_PARTY_ODD)
  1466. X            puts("odd");
  1467. X            else
  1468. X            puts("even");
  1469. X        }
  1470. X        } else {
  1471. X        puts("off");
  1472. X        }
  1473. X        printf("protocol is ");
  1474. X        if (ioc->io_SerFlags & SERF_7WIRE)
  1475. X        printf("7wire ");
  1476. X        if ((ioc->io_SerFlags & SERF_XDISABLED) == 0)
  1477. X        printf("xon-xoff");
  1478. X        if ((ioc->io_SerFlags & SERF_7WIRE) == 0 && (ioc->io_SerFlags & SERF_XDISABLED))
  1479. X        printf("none");
  1480. X        puts("");
  1481. X        fflush(stdout);
  1482. X
  1483. X        *pbaud = Baud = ioc->io_Baud;
  1484. X        if (DoIO((IOR *)ioc) != 0)
  1485. X        dneterror("Unable to set serial parameters");
  1486. X    }
  1487. X    }
  1488. X
  1489. X    RNet->IOSer.io_Command = CMD_READ;
  1490. X    RNet->IOSer.io_Message.mn_Node.ln_Name = (char *)RNET_REQ;
  1491. X
  1492. X    CNet->IOSer.io_Command = CMD_WRITE;
  1493. X    CNet->IOSer.io_Message.mn_Node.ln_Name = (char *)WNET_REQ;
  1494. X
  1495. X    Iosw = *CNet;
  1496. X
  1497. X    CNet->IOSer.io_Message.mn_Node.ln_Name = (char *)CNET_REQ;
  1498. X
  1499. X    puts("net open");
  1500. X}
  1501. X
  1502. X/*
  1503. X *  Closedown the network.
  1504. X */
  1505. X
  1506. Xvoid
  1507. XNetClose()
  1508. X{
  1509. X    NetAbortRead();
  1510. X    NetWaitWrite();
  1511. X    if (SerialIsOpen)
  1512. X    CloseDevice((IOR *)RNet);
  1513. X    if (RNet)
  1514. X    FreeMem(RNet, sizeof(IOSER));
  1515. X    if (CNet)
  1516. X    FreeMem(CNet, sizeof(IOSER));
  1517. X    SerialIsOpen = 0;
  1518. X    RNet = CNet = NULL;
  1519. X}
  1520. X
  1521. X/*
  1522. X *  NETCLWRITE()
  1523. X *
  1524. X *  Clear write request which was GetMsg()'d in DNET.C instead of
  1525. X *  WaitIO()'d here.
  1526. X */
  1527. X
  1528. Xvoid
  1529. XNetClWrite(ior)
  1530. XIOSER *ior;
  1531. X{
  1532. X    if (ior == &Iosw)
  1533. X    IoswIP = 0;
  1534. X}
  1535. X
  1536. Xvoid
  1537. XNetWrite(buf, bytes)
  1538. Xubyte *buf;
  1539. Xint bytes;
  1540. X{
  1541. X    if (PDebug) {
  1542. X    short i;
  1543. X
  1544. X    LastWasWrite = 1;
  1545. X    printf("WRITE %03x Bytes:", bytes);
  1546. X    for (i = 0; i < bytes; ++i)
  1547. X        printf(" %02x", buf[i]);
  1548. X    printf("\n");
  1549. X    }
  1550. X
  1551. X    if (!SerialIsOpen)
  1552. X    return;
  1553. X
  1554. X    if (IoswIP) {
  1555. X    WaitIO((IOR *)&Iosw);
  1556. X    IoswIP = 0;
  1557. X    }
  1558. X
  1559. X    if (bytes) {
  1560. X    Iosw.IOSer.io_Message.mn_Node.ln_Name = (char *)WNET_REQ;
  1561. X    Iosw.IOSer.io_Data = (APTR)buf;
  1562. X    Iosw.IOSer.io_Length = bytes;
  1563. X    SendIO((IOR *)&Iosw);
  1564. X    IoswIP = 1;
  1565. X    }
  1566. X    fixsignal(Iosw.IOSer.io_Message.mn_ReplyPort);
  1567. X}
  1568. X
  1569. Xvoid
  1570. XNetBreak()
  1571. X{
  1572. X    if (SerialIsOpen) {
  1573. X    CNet->IOSer.io_Command = SDCMD_BREAK;
  1574. X    DoIO((IOR *)CNet);
  1575. X    fixsignal(Iosw.IOSer.io_Message.mn_ReplyPort);
  1576. X    }
  1577. X}
  1578. X
  1579. X/*
  1580. X *  NETREADY()
  1581. X *
  1582. X *  Using the specified inactive request, return the # bytes ready and
  1583. X *  the carrier status.
  1584. X */
  1585. X
  1586. XNetReady()
  1587. X{
  1588. X    long n = 0;
  1589. X
  1590. X    if (SerialIsOpen && RecvEnabled) {
  1591. X    CNet->IOSer.io_Command = SDCMD_QUERY;
  1592. X    if (DoIO((IOR *)CNet) == 0)
  1593. X        n = CNet->IOSer.io_Actual;
  1594. X    Cd = !(CNet->io_Status & (1 << 5));
  1595. X    }
  1596. X    return(n);
  1597. X}
  1598. X
  1599. X/*
  1600. X *  SetBaudRate()
  1601. X */
  1602. X
  1603. XSetBaudRate(baud)
  1604. Xlong baud;
  1605. X{
  1606. X    long result;
  1607. X
  1608. X    if (Getty)
  1609. X    return(0);
  1610. X    if (TOBaud == 0)
  1611. X    SetTimeouts(baud);
  1612. X    if (CNet)
  1613. X    CNet->io_Baud = baud;
  1614. X    if (!SerialIsOpen)
  1615. X    return(1);
  1616. X    SaveState();
  1617. X    CNet->IOSer.io_Command = SDCMD_SETPARAMS;
  1618. X    result = DoIO((IOR *)CNet);
  1619. X    RestoreState();
  1620. X
  1621. X    if (result)
  1622. X    printf("Unable to set baud rate to %d\n", baud);
  1623. X
  1624. X    if (!result && PDebug)
  1625. X    printf("Baud rate set to %d\n", baud);
  1626. X
  1627. X    return(0);  /*  don't abort whether we can or not   */
  1628. X}
  1629. X
  1630. X/*
  1631. X *  Assumes CNet holds current settings
  1632. X */
  1633. X
  1634. Xvoid
  1635. XDropDTR()
  1636. X{
  1637. X    if (SerialIsOpen) {     /*  only if serial.device currently open    */
  1638. X    NetSerialOff();
  1639. X    Delay(50*4);
  1640. X    NetSerialOn();
  1641. X    }
  1642. X}
  1643. X
  1644. XIOSER *
  1645. XNetAbortRead()
  1646. X{
  1647. X    if (IosrIP) {
  1648. X    if (SerialIsOpen && RecvEnabled) {
  1649. X        AbortIO((IOR *)RNet);
  1650. X        WaitIO((IOR *)RNet);
  1651. X    }
  1652. X    IosrIP = 0;
  1653. X    }
  1654. X    return(RNet);
  1655. X}
  1656. X
  1657. X/*
  1658. X *  NetStartRead(bytes)
  1659. X */
  1660. X
  1661. Xstatic long  SaveLen;
  1662. X
  1663. Xvoid
  1664. XNetStartRead(len)
  1665. Xlong len;
  1666. X{
  1667. X    if (len > sizeof(RBuf))
  1668. X    len = sizeof(RBuf);
  1669. X
  1670. X    if (SerialIsOpen && RecvEnabled) {
  1671. X    if (IosrIP)
  1672. X        NetAbortRead();
  1673. X    RNet->IOSer.io_Data = (APTR)RBuf;
  1674. X    SaveLen = RNet->IOSer.io_Length = len;
  1675. X    SendIO((IOR *)RNet);
  1676. X    } else {
  1677. X    SaveLen = len;
  1678. X    RNet->IOSer.io_Actual = 0;
  1679. X    }
  1680. X    IosrIP = 1;
  1681. X}
  1682. X
  1683. XIOSER *
  1684. XNetReadReady()
  1685. X{
  1686. X    return((IOSER *)CheckIO((IOR *)RNet));
  1687. X}
  1688. X
  1689. XNetReadReturned(pptr)
  1690. Xubyte **pptr;
  1691. X{
  1692. X    long bytes = 0;
  1693. X
  1694. X    IosrIP = 0;
  1695. X
  1696. X    bytes = RNet->IOSer.io_Actual;
  1697. X    *pptr = RBuf;
  1698. X
  1699. X    if (PDebug) {
  1700. X    short i = 0;
  1701. X    if (LastWasWrite) {
  1702. X        LastWasWrite = 0;
  1703. X        printf("READ: ");
  1704. X    }
  1705. X    for (i = 0; i < bytes; ++i)
  1706. X        printf("%02x ", RBuf[i]);
  1707. X    fflush(stdout);
  1708. X    }
  1709. X    return(bytes);
  1710. X}
  1711. X
  1712. Xvoid
  1713. XNetWaitWrite()
  1714. X{
  1715. X    if (IoswIP) {
  1716. X    WaitIO((IOR *)&Iosw);
  1717. X    IoswIP = 0;
  1718. X    fixsignal(Iosw.IOSer.io_Message.mn_ReplyPort);
  1719. X    }
  1720. X}
  1721. X
  1722. Xstatic char SaveIosrIP;
  1723. X
  1724. Xvoid
  1725. XSaveState()
  1726. X{
  1727. X    if (SaveIosrIP = IosrIP)
  1728. X    NetAbortRead();
  1729. X    NetWaitWrite();
  1730. X}
  1731. X
  1732. Xvoid
  1733. XRestoreState()
  1734. X{
  1735. X    if (SaveIosrIP)
  1736. X    NetStartRead(SaveLen);
  1737. X}
  1738. X
  1739. Xvoid
  1740. XNetRecvOff()
  1741. X{
  1742. X    if (RecvEnabled) {
  1743. X    SaveState();
  1744. X    RecvEnabled = 0;
  1745. X    }
  1746. X}
  1747. X
  1748. Xvoid
  1749. XNetRecvOn()
  1750. X{
  1751. X    if (!RecvEnabled) {
  1752. X    RecvEnabled = 1;
  1753. X    RestoreState();
  1754. X    }
  1755. X}
  1756. X
  1757. Xvoid
  1758. XNetSerialOff()
  1759. X{
  1760. X    if (SerialIsOpen) {
  1761. X    SaveState();            /*  make sure no requests pending   */
  1762. X    CloseDevice((IOR *)RNet);   /*  close the device                */
  1763. X    SerialIsOpen = 0;
  1764. X    }
  1765. X}
  1766. X
  1767. Xvoid
  1768. XNetSerialOn()
  1769. X{
  1770. X    if (!SerialIsOpen) {
  1771. X    if (OpenDevice(DevName, UnitNum, (IOR *)RNet, 0))      /* OH HELL! */
  1772. X        return;
  1773. X
  1774. X    /*
  1775. X     *  Fix the Device / Unit fields and restore the previous
  1776. X     *  modes.
  1777. X     */
  1778. X
  1779. X    SerialIsOpen = 1;
  1780. X    Iosw.IOSer.io_Device = RNet->IOSer.io_Device;
  1781. X    Iosw.IOSer.io_Unit   = RNet->IOSer.io_Unit;
  1782. X
  1783. X    CNet->IOSer.io_Device = RNet->IOSer.io_Device;
  1784. X    CNet->IOSer.io_Unit   = RNet->IOSer.io_Unit;
  1785. X
  1786. X    RNet->IOSer.io_Command = CMD_READ;
  1787. X                /*  restore params            */
  1788. X    CNet->IOSer.io_Command = SDCMD_SETPARAMS;
  1789. X    CNet->io_SerFlags = SERF_SHARED|SERF_XDISABLED|SERF_RAD_BOOGIE;
  1790. X    DoIO((IOR *)CNet);
  1791. X    RestoreState();         /*  restore pending read req.       */
  1792. X    }
  1793. X    return;
  1794. X}
  1795. X
  1796. END_OF_FILE
  1797. if test 8314 -ne `wc -c <'amiga/dnet/sernet.c'`; then
  1798.     echo shar: \"'amiga/dnet/sernet.c'\" unpacked with wrong size!
  1799. fi
  1800. # end of 'amiga/dnet/sernet.c'
  1801. fi
  1802. if test -f 'amiga/server/sgcopy.c' -a "${1}" != "-c" ; then 
  1803.   echo shar: Will not clobber existing file \"'amiga/server/sgcopy.c'\"
  1804. else
  1805. echo shar: Extracting \"'amiga/server/sgcopy.c'\" \(8179 characters\)
  1806. sed "s/^X//" >'amiga/server/sgcopy.c' <<'END_OF_FILE'
  1807. X
  1808. X/*
  1809. X *  SGCOPY.C     V1.1
  1810. X *
  1811. X *  DNET (c)Copyright 1988, Matthew Dillon, All Rights Reserved.
  1812. X *
  1813. X *  GET-COPY SERVER    (NEW COPY SERVER)
  1814. X *
  1815. X *  The current version only accepts one connection at a time.    This server
  1816. X *  will send requested files to the remote machine.
  1817. X *
  1818. X *  length in 68000 longword format.
  1819. X *
  1820. X *  ACCESS RESTRICTIONS:
  1821. X *
  1822. X *    Remote access restrictions are according to DNET_GROUP or DNET_READ
  1823. X *
  1824. X *    DNET_READ >= 9        Full Access
  1825. X *    DNET_READ <  9        According to comment field (AC=n) or group acc.
  1826. X *                (GR=n) matches DNET_GROUP)
  1827. X *
  1828. X *    When searching for access rights, the comment field of the file/dir
  1829. X *    requested is checked first.  If empty, the parent dir is checked.
  1830. X *    This continues (parent diring) until root is found or a comment
  1831. X *    field with access info in it.
  1832. X */
  1833. X
  1834. X#include "defs.h"
  1835. X
  1836. Xtypedef struct {
  1837. X    char    Cmd;
  1838. X    char    Str[64];
  1839. X    long    Val;
  1840. X} HDR;
  1841. X
  1842. Xextern int Enable_Abort;
  1843. Xchar Buf[8192];
  1844. Xvoid *Chan;
  1845. X
  1846. Xvoid SGCopy ARGS((void));
  1847. Xint PutObject ARGS((char *));
  1848. Xint PutDir ARGS((char *, int));
  1849. Xint PutFile ARGS((char *, int));
  1850. Xint WriteHeader ARGS((char, char *, long));
  1851. Xint ReadHeader ARGS((HDR *));
  1852. X
  1853. Xint
  1854. Xbrk()
  1855. X{
  1856. X    return(0);
  1857. X}
  1858. X
  1859. Xvoid
  1860. X#ifdef LATTICE
  1861. X_main(str)
  1862. X#else
  1863. X_main(len,str)
  1864. X#endif
  1865. Xchar *str;
  1866. X{
  1867. X    struct MsgPort *port;
  1868. X    PROC    *myproc = (PROC *)FindTask(NULL);
  1869. X    long    savedir;
  1870. X    long    mask, rmask;
  1871. X
  1872. X    onbreak(brk);
  1873. X
  1874. X    if (strncmp(str, "__dnet", 6) != 0) {
  1875. X    Version("SGCopy", VERSION, SGCOPY_VERSION);
  1876. X    _exit(0);
  1877. X    }
  1878. X
  1879. X    port = DListen(PORT_GFILECOPY);
  1880. X    WaitPort(&myproc->pr_MsgPort);
  1881. X    ReplyMsg(GetMsg(&myproc->pr_MsgPort));
  1882. X    savedir = Lock("", SHARED_LOCK);   /* duplicate current dir    */
  1883. X    if (!savedir) {
  1884. X    DUnListen(port);
  1885. X    _exit(1);
  1886. X    }
  1887. X    savedir = CurrentDir(savedir);              /* CD dup, returns original */
  1888. X    mask = SIGBREAKF_CTRL_C|(1 << port->mp_SigBit);
  1889. X    for (;;) {
  1890. X    long dupdir = DupLock(myproc->pr_CurrentDir);
  1891. X    rmask = Wait(mask);
  1892. X    if (rmask & SIGBREAKF_CTRL_C) {
  1893. X        UnLock(CurrentDir(dupdir));
  1894. X        break;
  1895. X    }
  1896. X    while (Chan = DAccept(port)) {
  1897. X        SGCopy();
  1898. X        DClose(Chan);
  1899. X    }
  1900. X    UnLock(CurrentDir(dupdir));
  1901. X    }
  1902. X    UnLock(CurrentDir(savedir));                /* restore original         */
  1903. X    DUnListen(port);
  1904. X}
  1905. X
  1906. Xvoid
  1907. XSGCopy()
  1908. X{
  1909. X    short error;
  1910. X    static HDR Hdr;
  1911. X
  1912. X    error = WriteHeader('H', "Hello, GCopy server V1.30", 0);
  1913. X    if (error)
  1914. X    return;
  1915. X    switch(ReadHeader(&Hdr)) {
  1916. X    case -1:
  1917. X    return;
  1918. X    case 'H':
  1919. X    break;
  1920. X    }
  1921. X    while (!error) {
  1922. X    switch(ReadHeader(&Hdr)) {
  1923. X    case 'G':
  1924. X        error = PutObject(Hdr.Str);
  1925. X        break;
  1926. X    case 'E':
  1927. X        goto done;
  1928. X    case 'P':   /*  put-files, not implemented  */
  1929. X    default:
  1930. X        error = 1;
  1931. X        break;
  1932. X    }
  1933. X    }
  1934. Xdone:
  1935. X    ;
  1936. X}
  1937. X
  1938. Xint
  1939. XPutObject(str)
  1940. Xchar *str;
  1941. X{
  1942. X    long lock;
  1943. X    FIB *fib = malloc(sizeof(FIB));
  1944. X    short error = 0;
  1945. X    short access = GetEnvVal(DNET_READ);
  1946. X    short group  = GetEnvVal(DNET_GROUP);
  1947. X
  1948. X    mountrequest(0);
  1949. X    lock = Lock(str, SHARED_LOCK);
  1950. X    mountrequest(1);
  1951. X    if (lock == NULL || !Examine(lock, fib)) {     /*  unable to find it!  */
  1952. X    error = WriteHeader('N', "Unable to find object", 0);
  1953. X    goto done;
  1954. X    }
  1955. X
  1956. X    /*
  1957. X     *    Determine Access rights
  1958. X     *
  1959. X     *    If the file/dir or any parent dir has AC > your_ac, access is
  1960. X     *    denied.  If the file/dir and all parent dirs have neither an ACcess
  1961. X     *    or GRoup entry, access is denied.  If a group entry is found that
  1962. X     *    matches your group, access is allowed (unless an AC is found > your_ac)
  1963. X     *
  1964. X     *    If your_ac is >= 9, no access checking of parent directories is
  1965. X     *    done at all.  However, access checking of downloaded files will
  1966. X     *    be done, and any AC values > your_ac will be disalloweds.
  1967. X     */
  1968. X
  1969. X    if (access < 9) {           /*  must check comment/access   */
  1970. X    short ok = 0;
  1971. X    long lock2 = DupLock(lock);
  1972. X    long tmp;
  1973. X    for (;;) {
  1974. X        short ac = 0;
  1975. X
  1976. X        while (ac >= 0) {       /*  check groups    */
  1977. X        short idx = 0;
  1978. X        ac = ExtractFieldVal(fib->fib_Comment, FS_GROUP, &idx);
  1979. X        if (ac >= 0 && ac == group) {
  1980. X            ok = 1;
  1981. X            break;
  1982. X        }
  1983. X        }
  1984. X        ac = ExtractFieldVal(fib->fib_Comment, FS_ACCESS, NULL);
  1985. X        if (ac >= 0) {                  /*  valid access field      */
  1986. X        if (ac <= access) {         /*  access ok               */
  1987. X            ok = 1;
  1988. X        } else {            /*    access not ok        */
  1989. X            ok = 0;
  1990. X            break;
  1991. X        }
  1992. X        }
  1993. X        if (tmp = ParentDir(lock2)) {   /*  check the par.dir */
  1994. X        UnLock(lock2);
  1995. X        lock2 = tmp;
  1996. X        fib->fib_Comment[0] = 0;
  1997. X        Examine(lock2, fib);
  1998. X        continue;
  1999. X        }
  2000. X        break;
  2001. X    }
  2002. X    UnLock(lock2);
  2003. X    if (!ok) {
  2004. X        error = WriteHeader('N', "Access Violation", 0);
  2005. X        goto done;
  2006. X    }
  2007. X    }
  2008. X    Examine(lock, fib);
  2009. X    UnLock(lock);
  2010. X    lock = NULL;
  2011. X    if (fib->fib_DirEntryType > 0) {
  2012. X    error = PutDir(str, access);
  2013. X    } else {
  2014. X    error = PutFile(str, access);
  2015. X    }
  2016. Xdone:
  2017. X    if (lock)
  2018. X    UnLock(lock);
  2019. X    free(fib);
  2020. X    return((int)error);
  2021. X}
  2022. X
  2023. Xint
  2024. XPutDir(name, access)
  2025. Xchar *name;
  2026. Xint access;
  2027. X{
  2028. X    long lock = Lock(name, SHARED_LOCK);
  2029. X    FIB *fib = malloc(sizeof(FIB));
  2030. X    static HDR Hdr;
  2031. X    short error = 0;
  2032. X    short ac;
  2033. X
  2034. X    if (!lock || !Examine(lock, fib)) {
  2035. X    WriteHeader('N', "Possible Disk Error", 0);
  2036. X    error = 1;
  2037. X    goto done;
  2038. X    }
  2039. X
  2040. X    ac = ExtractFieldVal(fib->fib_Comment, FS_ACCESS, NULL);
  2041. X    if (ac >= 0 && ac > access) {
  2042. X    error = WriteHeader('S', fib->fib_FileName, 0);
  2043. X    goto done;
  2044. X    }
  2045. X
  2046. X    if (error = WriteHeader('D', fib->fib_FileName, 0))
  2047. X    goto done;
  2048. X    switch(ReadHeader(&Hdr)) {
  2049. X    case 'Y':
  2050. X    break;
  2051. X    case 'S':
  2052. X    goto done;
  2053. X    case 'N':
  2054. X    error = 1;
  2055. X    break;
  2056. X    default:
  2057. X    error = 1;
  2058. X    break;
  2059. X    }
  2060. X    if (error)
  2061. X    goto done;
  2062. X    while (ExNext(lock, fib)) {     /*  try to give him the files   */
  2063. X    if (fib->fib_DirEntryType > 0) {
  2064. X        long oldlock = CurrentDir(lock);
  2065. X        error = PutDir(fib->fib_FileName, access);
  2066. X        CurrentDir(oldlock);
  2067. X        if (error)
  2068. X        break;
  2069. X    } else {
  2070. X        long oldlock = CurrentDir(lock);
  2071. X        error = PutFile(fib->fib_FileName, access);
  2072. X        CurrentDir(oldlock);
  2073. X        if (error)
  2074. X        break;
  2075. X    }
  2076. X    }
  2077. X    if (!error)
  2078. X    WriteHeader('E', "Possible Disk Error", 0);
  2079. Xdone:
  2080. X    free(fib);
  2081. X    if (lock)
  2082. X    UnLock(lock);
  2083. X    return((int)error);
  2084. X}
  2085. X
  2086. Xint
  2087. XPutFile(name, access)
  2088. Xchar *name;
  2089. Xint access;
  2090. X{
  2091. X    long lock = Lock(name, SHARED_LOCK);
  2092. X    long fh = NULL;
  2093. X    FIB *fib = malloc(sizeof(FIB));
  2094. X    static HDR Hdr;
  2095. X    long len;
  2096. X    short error = 0;
  2097. X    short ac;
  2098. X
  2099. X    if (!lock || !Examine(lock, fib)) {
  2100. X    WriteHeader('N', "Possible Disk Error", 0);
  2101. X    error = 1;
  2102. X    goto done;
  2103. X    }
  2104. X
  2105. X    ac = ExtractFieldVal(fib->fib_Comment, FS_ACCESS, NULL);
  2106. X    if (ac >= 0 && ac > access) {
  2107. X    error = WriteHeader('S', fib->fib_FileName, 0);
  2108. X    goto done;
  2109. X    }
  2110. X
  2111. X    fh = Open(name, 1005);
  2112. X    if (fh == NULL)         /*  don't do anything if unable to open it */
  2113. X    goto done;
  2114. X    Seek(fh, 0L, 1);
  2115. X    len = Seek(fh, 0L, 0);
  2116. X    if (error = WriteHeader('F', fib->fib_FileName, len))
  2117. X    goto done;
  2118. X    switch(ReadHeader(&Hdr)) {
  2119. X    case 'Y':
  2120. X    Seek(fh, Hdr.Val, -1);  /*  start pos.  */
  2121. X    len -= Hdr.Val;
  2122. X    if (len < 0)
  2123. X        len = 0;
  2124. X    break;
  2125. X    case 'S':
  2126. X    goto done;
  2127. X    case 'N':
  2128. X    error = 1;
  2129. X    break;
  2130. X    default:
  2131. X    error = 1;
  2132. X    break;
  2133. X    }
  2134. X    if (error)
  2135. X    goto done;
  2136. X    while (len) {
  2137. X    long n = (len > sizeof(Buf)) ? sizeof(Buf) : len;
  2138. X
  2139. X    if (Read(fh, Buf, n) != n) {    /*  read failed! */
  2140. X        error = 10;
  2141. X        goto done;
  2142. X    }
  2143. X    if (DWrite(Chan, Buf, n) != n) {
  2144. X        error = 10;
  2145. X        goto done;
  2146. X    }
  2147. X    len -= n;
  2148. X    }
  2149. Xdone:
  2150. X    free(fib);
  2151. X    if (fh)
  2152. X    Close(fh);
  2153. X    if (lock)
  2154. X    UnLock(lock);
  2155. X    return((int)error);
  2156. X}
  2157. X
  2158. Xint
  2159. XWriteHeader(c, str, len)
  2160. Xchar c;
  2161. Xchar *str;
  2162. Xlong len;
  2163. X{
  2164. X    ubyte sl;
  2165. X
  2166. X    if (str == NULL)
  2167. X    str = "";
  2168. X    sl = strlen(str);
  2169. X
  2170. X    if (DWrite(Chan, &c, 1) < 0)
  2171. X    return(1);
  2172. X    if (DWrite(Chan, &sl,1) < 0)
  2173. X    return(1);
  2174. X    if (DWrite(Chan, str, sl) != sl)
  2175. X    return(1);
  2176. X    if (DWrite(Chan, &len, 4) != 4)
  2177. X    return(1);
  2178. X    return(0);
  2179. X}
  2180. X
  2181. Xint
  2182. XReadHeader(hdr)
  2183. XHDR *hdr;
  2184. X{
  2185. X    ubyte sl;
  2186. X    ubyte cmd;
  2187. X
  2188. X    hdr->Cmd = -1;
  2189. X    if (DRead(Chan, &cmd, 1) != 1)
  2190. X    return(-1);
  2191. X    if (DRead(Chan, &sl, 1) != 1)
  2192. X    return(-1);
  2193. X    if (sl >= sizeof(hdr->Str)) {
  2194. X    return(-1);
  2195. X    }
  2196. X    if (DRead(Chan, hdr->Str, sl) != sl)
  2197. X    return(-1);
  2198. X    hdr->Str[sl] = 0;
  2199. X    if (DRead(Chan, &hdr->Val, 4) != 4)
  2200. X    return(-1);
  2201. X    hdr->Cmd = cmd;
  2202. X    return((int)hdr->Cmd);
  2203. X}
  2204. X
  2205. X
  2206. END_OF_FILE
  2207. if test 8179 -ne `wc -c <'amiga/server/sgcopy.c'`; then
  2208.     echo shar: \"'amiga/server/sgcopy.c'\" unpacked with wrong size!
  2209. fi
  2210. # end of 'amiga/server/sgcopy.c'
  2211. fi
  2212. if test -f 'unix/dnet/subs.c' -a "${1}" != "-c" ; then 
  2213.   echo shar: Will not clobber existing file \"'unix/dnet/subs.c'\"
  2214. else
  2215. echo shar: Extracting \"'unix/dnet/subs.c'\" \(8247 characters\)
  2216. sed "s/^X//" >'unix/dnet/subs.c' <<'END_OF_FILE'
  2217. X
  2218. X/*
  2219. X *  SUBS.C
  2220. X *
  2221. X *    DNET (c)Copyright 1988, Matthew Dillon, All Rights Reserved
  2222. X *
  2223. X *    Support subroutines
  2224. X *
  2225. X */
  2226. X
  2227. X#include "dnet.h"
  2228. X
  2229. X/*
  2230. X *   WRITESTREAM()
  2231. X *
  2232. X *    Queues new SCMD_?? level commands to be sent
  2233. X */
  2234. X
  2235. XWriteStream(sdcmd, buf, len, chan)
  2236. Xubyte *buf;
  2237. Xuword chan;
  2238. X{
  2239. X    register XIOR *ior = (XIOR *)malloc(sizeof(XIOR));
  2240. X
  2241. X    if (DDebug)
  2242. X    printf("-writestr cmd %ld (%ld bytes chan %ld)\n", sdcmd, len, chan);
  2243. X
  2244. X    ior->io_Data = (ubyte *)malloc(len);
  2245. X    ior->io_Length = len;
  2246. X    ior->io_Actual = 0;
  2247. X    ior->io_Command = sdcmd;
  2248. X    ior->io_Error = 0;
  2249. X    ior->io_Channel = chan;
  2250. X    ior->io_Pri = (chan > MAXCHAN) ? 126 : Chan[chan].pri;
  2251. X    bcopy(buf, ior->io_Data, len);
  2252. X    Enqueue(&TxList, ior);
  2253. X    /*
  2254. X     *    REMOVED 21 SEPT 1988
  2255. X     * do_wupdate();
  2256. X     */
  2257. X}
  2258. X
  2259. X/*
  2260. X *  ALLOC_CHANNEL()
  2261. X *
  2262. X *    Allocate a free channel.  Used in SCMD_OPEN and SCMD_ACKCMD
  2263. X */
  2264. X
  2265. Xalloc_channel()
  2266. X{
  2267. X    static ulong ran = 13;
  2268. X    register uword i;
  2269. X
  2270. X    ran = ((ran * 13) + 1) ^ (ran >> 9) + time(0);
  2271. X    for (i = ran % MAXCHAN; i < MAXCHAN; ++i) {
  2272. X    if (Chan[i].state == 0)
  2273. X        return(i);
  2274. X    }
  2275. X    for (i = ran % MAXCHAN; i < MAXCHAN; --i) {
  2276. X    if (Chan[i].state == 0)
  2277. X        return(i);
  2278. X    }
  2279. X    return(-1);
  2280. X}
  2281. X
  2282. X/*
  2283. X *    Remove all nodes with the given channel ID.
  2284. X */
  2285. X
  2286. XClearChan(list, chan, all)
  2287. XLIST *list;
  2288. Xuword chan;
  2289. X{
  2290. X    register XIOR *io, *in;
  2291. X
  2292. X    for (io = (XIOR *)list->lh_Head; io != (XIOR *)&list->lh_Tail; io = in) {
  2293. X    in = (XIOR *)io->io_Node.ln_Succ;
  2294. X    if (io->io_Channel == chan) {
  2295. X        if (all || io->io_Command == SCMD_DATA) {
  2296. X        io->io_Node.ln_Succ->ln_Pred = io->io_Node.ln_Pred;
  2297. X        io->io_Node.ln_Pred->ln_Succ = io->io_Node.ln_Succ;
  2298. X        free(io->io_Data);
  2299. X        free(io);
  2300. X        }
  2301. X    }
  2302. X    }
  2303. X}
  2304. X
  2305. X/*
  2306. X *  Queue a packet into a prioritized list.  FIFO is retained for packets
  2307. X *  of the same priority.  This implements one level of channel priorities,
  2308. X *  before the packets actually get queued to the network.  Since up to
  2309. X *  4 packets might be queued (200 * 4 = 800 bytes of data or 4 seconds @
  2310. X *  2400 baud), a second level of prioritization will also reduce the
  2311. X *  physical packet size when two channels at relatively large differing
  2312. X *  priorities are in use.
  2313. X *
  2314. X *    These and other list routines compatible with Amiga list routines.
  2315. X */
  2316. X
  2317. XEnqueue(list, ior)
  2318. XLIST *list;
  2319. XXIOR *ior;
  2320. X{
  2321. X    register XIOR *io;
  2322. X    char pri = ior->io_Pri;
  2323. X
  2324. X    io = (XIOR *)list->lh_Head;
  2325. X    while (io != (XIOR *)&list->lh_Tail) {
  2326. X    if (pri > io->io_Pri)
  2327. X        break;
  2328. X    io = (XIOR *)io->io_Node.ln_Succ;
  2329. X    }
  2330. X    ior->io_Node.ln_Succ = (NODE *)io;
  2331. X    ior->io_Node.ln_Pred = io->io_Node.ln_Pred;
  2332. X    ior->io_Node.ln_Succ->ln_Pred = (NODE *)ior;
  2333. X    ior->io_Node.ln_Pred->ln_Succ = (NODE *)ior;
  2334. X}
  2335. X
  2336. XAddTail(list, node)
  2337. XLIST *list;
  2338. XNODE *node;
  2339. X{
  2340. X    node->ln_Succ = (NODE *)&list->lh_Tail;
  2341. X    node->ln_Pred = list->lh_TailPred;
  2342. X    node->ln_Succ->ln_Pred = node;
  2343. X    node->ln_Pred->ln_Succ = node;
  2344. X}
  2345. X
  2346. XAddHead(list, node)
  2347. XLIST *list;
  2348. XNODE *node;
  2349. X{
  2350. X    node->ln_Succ = list->lh_Head;
  2351. X    node->ln_Pred = (NODE *)list;
  2352. X    node->ln_Succ->ln_Pred = node;
  2353. X    node->ln_Pred->ln_Succ = node;
  2354. X}
  2355. X
  2356. Xubyte *
  2357. XRemHead(list)
  2358. XLIST *list;
  2359. X{
  2360. X    NODE *node;
  2361. X
  2362. X    node = list->lh_Head;
  2363. X    if (node->ln_Succ == NULL)
  2364. X    return(NULL);
  2365. X    node->ln_Succ->ln_Pred = node->ln_Pred;
  2366. X    node->ln_Pred->ln_Succ = node->ln_Succ;
  2367. X    return((ubyte *)node);
  2368. X}
  2369. X
  2370. XNewList(list)
  2371. XLIST *list;
  2372. X{
  2373. X    list->lh_Head = (NODE *)&list->lh_Tail;
  2374. X    list->lh_Tail = NULL;
  2375. X    list->lh_TailPred = (NODE *)&list->lh_Head;
  2376. X}
  2377. X
  2378. XGetNext(node)
  2379. XNODE *node;
  2380. X{
  2381. X    register NODE *next = node->ln_Succ;
  2382. X    if (*(long *)next)
  2383. X    return((long)next);
  2384. X    return(NULL);
  2385. X}
  2386. X
  2387. X/*
  2388. X *  CHKBUF
  2389. X *
  2390. X *    Checksum a buffer.  Uses a simple, but supposedly very good
  2391. X *    scheme.
  2392. X */
  2393. X
  2394. Xchkbuf(buf, bytes)
  2395. Xregister ubyte *buf;
  2396. Xregister uword bytes;
  2397. X{
  2398. X    register uword i;
  2399. X    register ubyte c1,c2;
  2400. X
  2401. X    for (i = c1 = c2 = 0; i < bytes; ++i) {
  2402. X    c1 += buf[i];
  2403. X    c2 += c1;
  2404. X    }
  2405. X    c1 = -(c1 + c2);
  2406. X    return((c1<<8)|c2);
  2407. X}
  2408. X
  2409. X/*
  2410. X *   Write timeout signal handler.
  2411. X */
  2412. X
  2413. Xsigwto()
  2414. X{
  2415. X    WTimedout = 1;
  2416. X}
  2417. X
  2418. XTimerOpen()
  2419. X{
  2420. X    static struct sigvec SA = { sigwto, 0, 0 };
  2421. X    sigvec(SIGALRM, &SA, NULL);
  2422. X}
  2423. X
  2424. XTimerClose()
  2425. X{
  2426. X    signal(SIGALRM, SIG_IGN);
  2427. X}
  2428. X
  2429. XWTimeout(secs)
  2430. X{
  2431. X    static struct itimerval itv;
  2432. X    struct itimerval ov;
  2433. X    long mask;
  2434. X
  2435. X    itv.it_value.tv_sec = secs;
  2436. X    itv.it_value.tv_usec= 0;
  2437. X
  2438. X    mask = sigblock(sigmask(SIGALRM));
  2439. X    setitimer(ITIMER_REAL, &itv, &ov);
  2440. X    Wto_act = 1;
  2441. X    WTimedout = 0;
  2442. X    sigsetmask(mask);
  2443. X    if (DDebug)
  2444. X    fprintf(stderr, "WTimeout set\n");
  2445. X}
  2446. X
  2447. Xdneterror(str)
  2448. Xchar *str;
  2449. X{
  2450. X    extern int errno;
  2451. X    register short i;
  2452. X    int er = errno;
  2453. X
  2454. X    NetClose();
  2455. X    TimerClose();
  2456. X    if (str)
  2457. X    fprintf(stderr, "%s %d\n", str, er);
  2458. X    else
  2459. X    fprintf(stderr, "-end-\n");
  2460. X    exit(1);
  2461. X}
  2462. X
  2463. X/*
  2464. X *    setenv(name, str).  name must be of the form "NAME="
  2465. X */
  2466. X
  2467. Xsetenv(name, str)
  2468. Xchar *name;
  2469. Xchar *str;
  2470. X{
  2471. X    extern char **environ;
  2472. X    static char **elist;
  2473. X    static int elen;
  2474. X    char *ptr;
  2475. X    int i, len;
  2476. X
  2477. X    len = strlen(name);
  2478. X    if (elist == NULL) {
  2479. X    for (i = 0; environ[i]; ++i);
  2480. X    elist = (char **)malloc((i+3)*sizeof(char *));
  2481. X    elen = i + 3;
  2482. X    bcopy(environ, elist, i*sizeof(char *));
  2483. X    environ = elist;
  2484. X    }
  2485. X    for (i = 0; elist[i]; ++i) {
  2486. X    if (strncmp(elist[i], name, len) == 0)
  2487. X        break;
  2488. X    }
  2489. X    if (i == elen) {
  2490. X    elen += 4;
  2491. X    elist = environ = (char **)realloc(elist, elen*sizeof(char *));
  2492. X    }
  2493. X    ptr = (char *)malloc(len + strlen(str) + 1);
  2494. X    sprintf(ptr, "%s%s", name, str);
  2495. X    if (elist[i]) {
  2496. X    elist[i] = ptr;
  2497. X    } else {
  2498. X    elist[i] = ptr;
  2499. X    elist[i+1] = NULL;
  2500. X    elen = i + 1;
  2501. X    }
  2502. X}
  2503. X
  2504. Xvoid
  2505. Xstartserver(port)
  2506. Xuword port;
  2507. X{
  2508. X    char dir[MAXPATHLEN];
  2509. X    struct passwd pw_info;
  2510. X    FILE *fi;
  2511. X
  2512. X    if (!port)
  2513. X    return;
  2514. X    if (getenv("DNETDIR")) {
  2515. X    strcpy(dir, getenv("DNETDIR"));
  2516. X    strcat(dir, "dnet.servers");
  2517. X    if (fi = fopen(dir, "r")) {
  2518. X        if (scan_for_server(fi, port))
  2519. X        return;
  2520. X    }
  2521. X    }
  2522. X    pw_info = *getpwuid(getuid());
  2523. X    strcpy(dir, pw_info.pw_dir);
  2524. X    strcat(dir, "/.dnet/dnet.servers");
  2525. X    if (fi = fopen(dir, "r")) {
  2526. X    if (scan_for_server(fi, port))
  2527. X        return;
  2528. X    }
  2529. X    /*
  2530. X     *    LAST TRY
  2531. X     */
  2532. X    if (fi = fopen(LASTTRYDNETSERVERS, "r")) {
  2533. X    if (scan_for_server(fi, port))
  2534. X        return;
  2535. X    }
  2536. X    fprintf(stderr, "Unable to find one of (1) dnet.servers or (2) server\n");
  2537. X    fprintf(stderr, "entry for port %d\n", port);
  2538. X    fflush(stderr);
  2539. X    return;
  2540. X}
  2541. X
  2542. Xscan_for_server(fi, port)
  2543. XFILE *fi;
  2544. Xshort port;
  2545. X{
  2546. X    char buf[256];
  2547. X    char path[MAXPATHLEN];
  2548. X    char cdir[MAXPATHLEN];
  2549. X    long portno;
  2550. X    short found = 0;
  2551. X    void checktilda();
  2552. X
  2553. X    while (fgets(buf, 256, fi)) {
  2554. X    if (sscanf(buf, "%ld %s %s", &portno, path, cdir) == 3) {
  2555. X        checktilda(path);
  2556. X        checktilda(cdir);
  2557. X        if (portno == port) {
  2558. X        if (!fork()) {
  2559. X            int i;
  2560. X            fclose(fi);
  2561. X            setuid(getuid());
  2562. X            signal(SIGHUP, SIG_DFL);
  2563. X            signal(SIGINT, SIG_DFL);
  2564. X            signal(SIGQUIT, SIG_DFL);
  2565. X            signal(SIGTERM, SIG_DFL);
  2566. X            signal(SIGCHLD, SIG_DFL);
  2567. X            signal(SIGTSTP, SIG_IGN);
  2568. X            ioctl(open("/dev/tty", 2), TIOCNOTTY, NULL);
  2569. X            i = open("/dev/null", O_RDWR, 0);
  2570. X            dup2(i, 0);
  2571. X            dup2(i, 1);
  2572. X            for (i = 3; i < 256; ++i)
  2573. X            close(i);
  2574. X            sprintf(buf, "server.%ld.%ld", port, getuid());
  2575. X            execl(path, buf, cdir, NULL);
  2576. X            fprintf(stderr, "Unable to exec server: %s\n", path);
  2577. X                fflush(stderr);
  2578. X            _exit(1);
  2579. X        }
  2580. X        sleep(4);    /* is a hack */
  2581. X        found = 1;
  2582. X        break;
  2583. X        }
  2584. X    }
  2585. X    }
  2586. X    fclose(fi);
  2587. X    return(found);
  2588. X}
  2589. X
  2590. Xvoid
  2591. Xchecktilda(buf)
  2592. Xchar *buf;
  2593. X{
  2594. X    if (buf[0] == '~') {
  2595. X    short bindex = 1;
  2596. X    short pathlen;
  2597. X    struct passwd pw_info, *pw;
  2598. X
  2599. X    pw_info.pw_dir = getenv("HOME");
  2600. X    if (buf[1] && buf[1] != '/') {
  2601. X        char username[128];
  2602. X        while (buf[bindex] && buf[bindex] != '/')
  2603. X        ++bindex;
  2604. X        bcopy(buf+1, username, bindex-1);
  2605. X        username[bindex-1] = 0;
  2606. X        if (pw = getpwnam(username)) {
  2607. X        pw_info = *pw;
  2608. X        } else {
  2609. X        fprintf(stderr, "Unable to find password entry for %s\n",
  2610. X            username
  2611. X        );
  2612. X        fprintf(stderr, "passing /tmp as dir for server");
  2613. X            fflush(stderr);
  2614. X        pw_info.pw_dir = "/tmp";
  2615. X        }
  2616. X    }
  2617. X
  2618. X    /*
  2619. X     * ~[username]<rest of path>     ->   <basedir><rest of path>
  2620. X     */
  2621. X
  2622. X    pathlen = strlen(pw_info.pw_dir);
  2623. X    bcopy(buf + bindex, buf + pathlen, strlen(buf + bindex) + 1);
  2624. X    bcopy(pw_info.pw_dir, buf, pathlen);
  2625. X    }
  2626. X    fflush(stderr);
  2627. X}
  2628. X
  2629. END_OF_FILE
  2630. if test 8247 -ne `wc -c <'unix/dnet/subs.c'`; then
  2631.     echo shar: \"'unix/dnet/subs.c'\" unpacked with wrong size!
  2632. fi
  2633. # end of 'unix/dnet/subs.c'
  2634. fi
  2635. echo shar: End of archive 5 \(of 8\).
  2636. cp /dev/null ark5isdone
  2637. MISSING=""
  2638. for I in 1 2 3 4 5 6 7 8 ; do
  2639.     if test ! -f ark${I}isdone ; then
  2640.     MISSING="${MISSING} ${I}"
  2641.     fi
  2642. done
  2643. if test "${MISSING}" = "" ; then
  2644.     echo You have unpacked all 8 archives.
  2645.     rm -f ark[1-9]isdone
  2646. else
  2647.     echo You still need to unpack the following archives:
  2648.     echo "        " ${MISSING}
  2649. fi
  2650. ##  End of shell archive.
  2651. exit 0
  2652. -- 
  2653. Mail submissions (sources or binaries) to <amiga@cs.odu.edu>.
  2654. Mail comments to the moderator at <amiga-request@cs.odu.edu>.
  2655. Post requests for sources, and general discussion to comp.sys.amiga.
  2656.